Added Google Contacts GData API package

blink/google/atom/auth.py

+#
+#    Copyright (C) 2009 Google Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+
+# This module is used for version 2 of the Google Data APIs.
+
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+
+import base64
+
+
+class BasicAuth(object):
+  """Sets the Authorization header as defined in RFC1945"""
+
+  def __init__(self, user_id, password):
+    self.basic_cookie = base64.encodestring(
+        '%s:%s' % (user_id, password)).strip()
+
+  def modify_request(self, http_request):
+    http_request.headers['Authorization'] = 'Basic %s' % self.basic_cookie
+
+  ModifyRequest = modify_request
+
+
+class NoAuth(object):
+
+  def modify_request(self, http_request):
+    pass

blink/google/atom/client.py

+#
+# Copyright (C) 2009 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""AtomPubClient provides CRUD ops. in line with the Atom Publishing Protocol.
+
+"""
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+from blink.google.atom import http_core as atom_http_core
+
+
+class Error(Exception):
+  pass
+
+
+class MissingHost(Error):
+  pass
+
+
+class AtomPubClient(object):
+  host = None
+  auth_token = None
+  ssl = False # Whether to force all requests over https
+
+  def __init__(self, http_client=None, host=None,
+               auth_token=None, source=None, **kwargs):
+    """Creates a new AtomPubClient instance.
+
+    Args:
+      source: The name of your application.
+      http_client: An object capable of performing HTTP requests through a
+                   request method. This object is used to perform the request
+                   when the AtomPubClient's request method is called. Used to
+                   allow HTTP requests to be directed to a mock server, or use
+                   an alternate library instead of the default of httplib to
+                   make HTTP requests.
+      host: str The default host name to use if a host is not specified in the
+            requested URI.
+      auth_token: An object which sets the HTTP Authorization header when its
+                  modify_request method is called.
+    """
+    self.http_client = http_client or atom_http_core.ProxiedHttpClient()
+    if host is not None:
+      self.host = host
+    if auth_token is not None:
+      self.auth_token = auth_token
+    self.source = source
+
+  def request(self, method=None, uri=None, auth_token=None,
+              http_request=None, **kwargs):
+    """Performs an HTTP request to the server indicated.
+
+    Uses the http_client instance to make the request.
+
+    Args:
+      method: The HTTP method as a string, usually one of 'GET', 'POST',
+              'PUT', or 'DELETE'
+      uri: The URI desired as a string or atom_http_core.Uri.
+      http_request:
+      auth_token: An authorization token object whose modify_request method
+                  sets the HTTP Authorization header.
+
+    Returns:
+      The results of calling self.http_client.request. With the default
+      http_client, this is an HTTP response object.
+    """
+    # Modify the request based on the AtomPubClient settings and parameters
+    # passed in to the request.
+    http_request = self.modify_request(http_request)
+    if isinstance(uri, (str, unicode)):
+      uri = atom_http_core.Uri.parse_uri(uri)
+    if uri is not None:
+      uri.modify_request(http_request)
+    if isinstance(method, (str, unicode)):
+      http_request.method = method
+    # Any unrecognized arguments are assumed to be capable of modifying the
+    # HTTP request.
+    for name, value in kwargs.iteritems():
+      if value is not None:
+        value.modify_request(http_request)
+    # Default to an http request if the protocol scheme is not set.
+    if http_request.uri.scheme is None:
+      http_request.uri.scheme = 'http'
+    # Override scheme. Force requests over https.
+    if self.ssl:
+      http_request.uri.scheme = 'https'
+    if http_request.uri.path is None:
+      http_request.uri.path = '/'
+    # Add the Authorization header at the very end. The Authorization header
+    # value may need to be calculated using information in the request.
+    if auth_token:
+      auth_token.modify_request(http_request)
+    elif self.auth_token:
+      self.auth_token.modify_request(http_request)
+    # Check to make sure there is a host in the http_request.
+    if http_request.uri.host is None:
+      raise MissingHost('No host provided in request %s %s' % (
+          http_request.method, str(http_request.uri)))
+    # Perform the fully specified request using the http_client instance.
+    # Sends the request to the server and returns the server's response.
+    return self.http_client.request(http_request)
+
+  Request = request
+
+  def get(self, uri=None, auth_token=None, http_request=None, **kwargs):
+    """Performs a request using the GET method, returns an HTTP response."""
+    return self.request(method='GET', uri=uri, auth_token=auth_token,
+                        http_request=http_request, **kwargs)
+
+  Get = get
+
+  def post(self, uri=None, data=None, auth_token=None, http_request=None,
+           **kwargs):
+    """Sends data using the POST method, returns an HTTP response."""
+    return self.request(method='POST', uri=uri, auth_token=auth_token,
+                        http_request=http_request, data=data, **kwargs)
+
+  Post = post
+
+  def put(self, uri=None, data=None, auth_token=None, http_request=None,
+          **kwargs):
+    """Sends data using the PUT method, returns an HTTP response."""
+    return self.request(method='PUT', uri=uri, auth_token=auth_token,
+                        http_request=http_request, data=data, **kwargs)
+
+  Put = put
+
+  def delete(self, uri=None, auth_token=None, http_request=None, **kwargs):
+    """Performs a request using the DELETE method, returns an HTTP response."""
+    return self.request(method='DELETE', uri=uri, auth_token=auth_token,
+                        http_request=http_request, **kwargs)
+
+  Delete = delete
+
+  def modify_request(self, http_request):
+    """Changes the HTTP request before sending it to the server.
+    
+    Sets the User-Agent HTTP header and fills in the HTTP host portion
+    of the URL if one was not included in the request (for this it uses
+    the self.host member if one is set). This method is called in
+    self.request.
+
+    Args:
+      http_request: An atom_http_core.HttpRequest() (optional) If one is
+                    not provided, a new HttpRequest is instantiated.
+
+    Returns:
+      An atom_http_core.HttpRequest() with the User-Agent header set and
+      if this client has a value in its host member, the host in the request
+      URL is set.
+    """
+    if http_request is None:
+      http_request = atom_http_core.HttpRequest()
+
+    if self.host is not None and http_request.uri.host is None:
+      http_request.uri.host = self.host
+
+    # Set the user agent header for logging purposes.
+    if self.source:
+      http_request.headers['User-Agent'] = '%s gdata-py/2.0.10' % self.source
+    else:
+      http_request.headers['User-Agent'] = 'gdata-py/2.0.10'
+
+    return http_request
+
+  ModifyRequest = modify_request

blink/google/atom/data.py

+#
+# Copyright (C) 2009 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# This module is used for version 2 of the Google Data APIs.
+
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+from blink.google.atom import core as atom_core
+
+
+ATOM_TEMPLATE = '{http://www.w3.org/2005/Atom}%s'
+APP_TEMPLATE_V1 = '{http://purl.org/atom/app#}%s'
+APP_TEMPLATE_V2 = '{http://www.w3.org/2007/app}%s'
+
+
+class Name(atom_core.XmlElement):
+  """The atom:name element."""
+  _qname = ATOM_TEMPLATE % 'name'
+
+
+class Email(atom_core.XmlElement):
+  """The atom:email element."""
+  _qname = ATOM_TEMPLATE % 'email'
+
+
+class Uri(atom_core.XmlElement):
+  """The atom:uri element."""
+  _qname = ATOM_TEMPLATE % 'uri'
+
+
+class Person(atom_core.XmlElement):
+  """A foundation class which atom:author and atom:contributor extend.
+
+  A person contains information like name, email address, and web page URI for
+  an author or contributor to an Atom feed.
+  """
+  name = Name
+  email = Email
+  uri = Uri
+
+
+class Author(Person):
+  """The atom:author element.
+
+  An author is a required element in Feed unless each Entry contains an Author.
+  """
+  _qname = ATOM_TEMPLATE % 'author'
+
+
+class Contributor(Person):
+  """The atom:contributor element."""
+  _qname = ATOM_TEMPLATE % 'contributor'
+
+
+class Link(atom_core.XmlElement):
+  """The atom:link element."""
+  _qname = ATOM_TEMPLATE % 'link'
+  href = 'href'
+  rel = 'rel'
+  type = 'type'
+  hreflang = 'hreflang'
+  title = 'title'
+  length = 'length'
+
+
+class Generator(atom_core.XmlElement):
+  """The atom:generator element."""
+  _qname = ATOM_TEMPLATE % 'generator'
+  uri = 'uri'
+  version = 'version'
+
+
+class Text(atom_core.XmlElement):
+  """A foundation class from which atom:title, summary, etc. extend.
+
+  This class should never be instantiated.
+  """
+  type = 'type'
+
+
+class Title(Text):
+  """The atom:title element."""
+  _qname = ATOM_TEMPLATE % 'title'
+
+
+class Subtitle(Text):
+  """The atom:subtitle element."""
+  _qname = ATOM_TEMPLATE % 'subtitle'
+
+
+class Rights(Text):
+  """The atom:rights element."""
+  _qname = ATOM_TEMPLATE % 'rights'
+
+
+class Summary(Text):
+  """The atom:summary element."""
+  _qname = ATOM_TEMPLATE % 'summary'
+
+
+class Content(Text):
+  """The atom:content element."""
+  _qname = ATOM_TEMPLATE % 'content'
+  src = 'src'
+
+
+class Category(atom_core.XmlElement):
+  """The atom:category element."""
+  _qname = ATOM_TEMPLATE % 'category'
+  term = 'term'
+  scheme = 'scheme'
+  label = 'label'
+
+
+class Id(atom_core.XmlElement):
+  """The atom:id element."""
+  _qname = ATOM_TEMPLATE % 'id'
+
+
+class Icon(atom_core.XmlElement):
+  """The atom:icon element."""
+  _qname = ATOM_TEMPLATE % 'icon'
+
+
+class Logo(atom_core.XmlElement):
+  """The atom:logo element."""
+  _qname = ATOM_TEMPLATE % 'logo'
+
+
+class Draft(atom_core.XmlElement):
+  """The app:draft element which indicates if this entry should be public."""
+  _qname = (APP_TEMPLATE_V1 % 'draft', APP_TEMPLATE_V2 % 'draft')
+
+
+class Control(atom_core.XmlElement):
+  """The app:control element indicating restrictions on publication.
+
+  The APP control element may contain a draft element indicating whether or
+  not this entry should be publicly available.
+  """
+  _qname = (APP_TEMPLATE_V1 % 'control', APP_TEMPLATE_V2 % 'control')
+  draft = Draft
+
+
+class Date(atom_core.XmlElement):
+  """A parent class for atom:updated, published, etc."""
+
+
+class Updated(Date):
+  """The atom:updated element."""
+  _qname = ATOM_TEMPLATE % 'updated'
+
+
+class Published(Date):
+  """The atom:published element."""
+  _qname = ATOM_TEMPLATE % 'published'
+
+
+class LinkFinder(object):
+  """An "interface" providing methods to find link elements
+
+  Entry elements often contain multiple links which differ in the rel
+  attribute or content type. Often, developers are interested in a specific
+  type of link so this class provides methods to find specific classes of
+  links.
+
+  This class is used as a mixin in Atom entries and feeds.
+  """
+
+  def find_url(self, rel):
+    """Returns the URL in a link with the desired rel value."""
+    for link in self.link:
+      if link.rel == rel and link.href:
+        return link.href
+    return None
+
+  FindUrl = find_url
+
+  def get_link(self, rel):
+    """Returns a link object which has the desired rel value.
+
+    If you are interested in the URL instead of the link object,
+    consider using find_url instead.
+    """
+    for link in self.link:
+      if link.rel == rel and link.href:
+        return link
+    return None
+
+  GetLink = get_link
+
+  def find_self_link(self):
+    """Find the first link with rel set to 'self'
+
+    Returns:
+      A str containing the link's href or None if none of the links had rel
+      equal to 'self'
+    """
+    return self.find_url('self')
+
+  FindSelfLink = find_self_link
+
+  def get_self_link(self):
+    return self.get_link('self')
+
+  GetSelfLink = get_self_link
+
+  def find_edit_link(self):
+    return self.find_url('edit')
+
+  FindEditLink = find_edit_link
+
+  def get_edit_link(self):
+    return self.get_link('edit')
+
+  GetEditLink = get_edit_link
+
+  def find_edit_media_link(self):
+    link = self.find_url('edit-media')
+    # Search for media-edit as well since Picasa API used media-edit instead.
+    if link is None:
+      return self.find_url('media-edit')
+    return link
+
+  FindEditMediaLink = find_edit_media_link
+
+  def get_edit_media_link(self):
+    link = self.get_link('edit-media')
+    if link is None:
+      return self.get_link('media-edit')
+    return link
+
+  GetEditMediaLink = get_edit_media_link
+
+  def find_next_link(self):
+    return self.find_url('next')
+
+  FindNextLink = find_next_link
+
+  def get_next_link(self):
+    return self.get_link('next')
+
+  GetNextLink = get_next_link
+
+  def find_license_link(self):
+    return self.find_url('license')
+
+  FindLicenseLink = find_license_link
+
+  def get_license_link(self):
+    return self.get_link('license')
+
+  GetLicenseLink = get_license_link
+
+  def find_alternate_link(self):
+    return self.find_url('alternate')
+
+  FindAlternateLink = find_alternate_link
+
+  def get_alternate_link(self):
+    return self.get_link('alternate')
+
+  GetAlternateLink = get_alternate_link
+
+
+class FeedEntryParent(atom_core.XmlElement, LinkFinder):
+  """A super class for atom:feed and entry, contains shared attributes"""
+  author = [Author]
+  category = [Category]
+  contributor = [Contributor]
+  id = Id
+  link = [Link]
+  rights = Rights
+  title = Title
+  updated = Updated
+
+  def __init__(self, atom_id=None, text=None, *args, **kwargs):
+    if atom_id is not None:
+      self.id = atom_id
+    atom_core.XmlElement.__init__(self, text=text, *args, **kwargs)
+
+
+class Source(FeedEntryParent):
+  """The atom:source element."""
+  _qname = ATOM_TEMPLATE % 'source'
+  generator = Generator
+  icon = Icon
+  logo = Logo
+  subtitle = Subtitle
+
+
+class Entry(FeedEntryParent):
+  """The atom:entry element."""
+  _qname = ATOM_TEMPLATE % 'entry'
+  content = Content
+  published = Published
+  source = Source
+  summary = Summary
+  control = Control
+
+
+class Feed(Source):
+  """The atom:feed element which contains entries."""
+  _qname = ATOM_TEMPLATE % 'feed'
+  entry = [Entry]
+
+
+class ExtensionElement(atom_core.XmlElement):
+  """Provided for backwards compatibility to the v1 atom.ExtensionElement."""
+
+  def __init__(self, tag=None, namespace=None, attributes=None,
+      children=None, text=None, *args, **kwargs):
+    if namespace:
+      self._qname = '{%s}%s' % (namespace, tag)
+    else:
+      self._qname = tag
+    self.children = children or []
+    self.attributes = attributes or {}
+    self.text = text
+
+  _BecomeChildElement = atom_core.XmlElement._become_child
+
+

blink/google/atom/http_interface.py

+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module provides a common interface for all HTTP requests.
+
+  HttpResponse: Represents the server's response to an HTTP request. Provides
+      an interface identical to httplib.HTTPResponse which is the response
+      expected from higher level classes which use HttpClient.request.
+
+  GenericHttpClient: Provides an interface (superclass) for an object 
+      responsible for making HTTP requests. Subclasses of this object are
+      used in AtomService and GDataService to make requests to the server. By
+      changing the http_client member object, the AtomService is able to make
+      HTTP requests using different logic (for example, when running on 
+      Google App Engine, the http_client makes requests using the App Engine
+      urlfetch API). 
+"""
+
+
+__author__ = 'api.jscudder (Jeff Scudder)'
+
+import StringIO
+
+
+USER_AGENT = '%s GData-Python/2.0.10'
+
+
+class Error(Exception):
+  pass
+
+
+class UnparsableUrlObject(Error):
+  pass
+
+
+class ContentLengthRequired(Error):
+  pass
+  
+
+class HttpResponse(object):
+  def __init__(self, body=None, status=None, reason=None, headers=None):
+    """Constructor for an HttpResponse object. 
+
+    HttpResponse represents the server's response to an HTTP request from
+    the client. The HttpClient.request method returns a httplib.HTTPResponse
+    object and this HttpResponse class is designed to mirror the interface
+    exposed by httplib.HTTPResponse.
+
+    Args:
+      body: A file like object, with a read() method. The body could also
+          be a string, and the constructor will wrap it so that 
+          HttpResponse.read(self) will return the full string.
+      status: The HTTP status code as an int. Example: 200, 201, 404.
+      reason: The HTTP status message which follows the code. Example: 
+          OK, Created, Not Found
+      headers: A dictionary containing the HTTP headers in the server's 
+          response. A common header in the response is Content-Length.
+    """
+    if body:
+      if hasattr(body, 'read'):
+        self._body = body
+      else:
+        self._body = StringIO.StringIO(body)
+    else:
+      self._body = None
+    if status is not None:
+      self.status = int(status)
+    else:
+      self.status = None
+    self.reason = reason
+    self._headers = headers or {}
+
+  def getheader(self, name, default=None):
+    if name in self._headers:
+      return self._headers[name]
+    else:
+      return default
+    
+  def read(self, amt=None):
+    if not amt:
+      return self._body.read()
+    else:
+      return self._body.read(amt)
+
+
+class GenericHttpClient(object):
+  debug = False
+
+  def __init__(self, http_client, headers=None):
+    """
+    
+    Args:
+      http_client: An object which provides a request method to make an HTTP 
+          request. The request method in GenericHttpClient performs a 
+          call-through to the contained HTTP client object.
+      headers: A dictionary containing HTTP headers which should be included
+          in every HTTP request. Common persistent headers include 
+          'User-Agent'.
+    """
+    self.http_client = http_client
+    self.headers = headers or {}
+
+  def request(self, operation, url, data=None, headers=None):
+    all_headers = self.headers.copy()
+    if headers:
+      all_headers.update(headers)
+    return self.http_client.request(operation, url, data=data, 
+        headers=all_headers)
+
+  def get(self, url, headers=None):
+    return self.request('GET', url, headers=headers)
+
+  def post(self, url, data, headers=None):
+    return self.request('POST', url, data=data, headers=headers)
+
+  def put(self, url, data, headers=None):
+    return self.request('PUT', url, data=data, headers=headers)
+
+  def delete(self, url, headers=None):
+    return self.request('DELETE', url, headers=headers)
+
+
+class GenericToken(object):
+  """Represents an Authorization token to be added to HTTP requests.
+  
+  Some Authorization headers included calculated fields (digital
+  signatures for example) which are based on the parameters of the HTTP
+  request. Therefore the token is responsible for signing the request
+  and adding the Authorization header. 
+  """
+  def perform_request(self, http_client, operation, url, data=None, 
+                      headers=None):
+    """For the GenericToken, no Authorization token is set."""
+    return http_client.request(operation, url, data=data, headers=headers)
+
+  def valid_for_scope(self, url):
+    """Tells the caller if the token authorizes access to the desired URL.
+    
+    Since the generic token doesn't add an auth header, it is not valid for
+    any scope.
+    """
+    return False
+
+

blink/google/atom/token_store.py

+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module provides a TokenStore class which is designed to manage
+auth tokens required for different services.
+
+Each token is valid for a set of scopes which is the start of a URL. An HTTP
+client will use a token store to find a valid Authorization header to send
+in requests to the specified URL. If the HTTP client determines that a token
+has expired or been revoked, it can remove the token from the store so that
+it will not be used in future requests.
+"""
+
+
+__author__ = 'api.jscudder (Jeff Scudder)'
+
+from blink.google.atom import http_interface as atom_http_interface, url as atom_url
+
+
+SCOPE_ALL = 'http'
+
+
+class TokenStore(object):
+  """Manages Authorization tokens which will be sent in HTTP headers."""
+  def __init__(self, scoped_tokens=None):
+    self._tokens = scoped_tokens or {}
+
+  def add_token(self, token):
+    """Adds a new token to the store (replaces tokens with the same scope).
+
+    Args:
+      token: A subclass of http_interface.GenericToken. The token object is 
+          responsible for adding the Authorization header to the HTTP request.
+          The scopes defined in the token are used to determine if the token
+          is valid for a requested scope when find_token is called.
+
+    Returns:
+      True if the token was added, False if the token was not added becase
+      no scopes were provided.
+    """
+    if not hasattr(token, 'scopes') or not token.scopes:
+      return False
+
+    for scope in token.scopes:
+      self._tokens[str(scope)] = token
+    return True  
+
+  def find_token(self, url):
+    """Selects an Authorization header token which can be used for the URL.
+
+    Args:
+      url: str or atom_url.Url or a list containing the same.
+          The URL which is going to be requested. All
+          tokens are examined to see if any scopes begin match the beginning
+          of the URL. The first match found is returned.
+
+    Returns:
+      The token object which should execute the HTTP request. If there was
+      no token for the url (the url did not begin with any of the token
+      scopes available), then the atom_http_interface.GenericToken will be 
+      returned because the GenericToken calls through to the http client
+      without adding an Authorization header.
+    """
+    if url is None:
+      return None
+    if isinstance(url, (str, unicode)):
+      url = atom_url.parse_url(url)
+    if url in self._tokens:
+      token = self._tokens[url]
+      if token.valid_for_scope(url):
+        return token
+      else:
+        del self._tokens[url]
+    for scope, token in self._tokens.iteritems():
+      if token.valid_for_scope(url):
+        return token
+    return atom_http_interface.GenericToken()
+
+  def remove_token(self, token):
+    """Removes the token from the token_store.
+
+    This method is used when a token is determined to be invalid. If the
+    token was found by find_token, but resulted in a 401 or 403 error stating
+    that the token was invlid, then the token should be removed to prevent
+    future use.
+
+    Returns:
+      True if a token was found and then removed from the token
+      store. False if the token was not in the TokenStore.
+    """
+    token_found = False
+    scopes_to_delete = []
+    for scope, stored_token in self._tokens.iteritems():
+      if stored_token == token:
+        scopes_to_delete.append(scope)
+        token_found = True
+    for scope in scopes_to_delete:
+      del self._tokens[scope]
+    return token_found
+
+  def remove_all_tokens(self):
+    self._tokens = {} 

blink/google/atom/url.py

+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+__author__ = 'api.jscudder (Jeff Scudder)'
+
+
+import urlparse
+import urllib
+
+
+DEFAULT_PROTOCOL = 'http'
+DEFAULT_PORT = 80
+
+
+def parse_url(url_string):
+  """Creates a Url object which corresponds to the URL string.
+  
+  This method can accept partial URLs, but it will leave missing
+  members of the Url unset.
+  """
+  parts = urlparse.urlparse(url_string)
+  url = Url()
+  if parts[0]:
+    url.protocol = parts[0]
+  if parts[1]:
+    host_parts = parts[1].split(':')
+    if host_parts[0]:
+      url.host = host_parts[0]
+    if len(host_parts) > 1:
+      url.port = host_parts[1]
+  if parts[2]:
+    url.path = parts[2]
+  if parts[4]:
+    param_pairs = parts[4].split('&')
+    for pair in param_pairs:
+      pair_parts = pair.split('=')
+      if len(pair_parts) > 1:
+        url.params[urllib.unquote_plus(pair_parts[0])] = (
+            urllib.unquote_plus(pair_parts[1]))
+      elif len(pair_parts) == 1:
+        url.params[urllib.unquote_plus(pair_parts[0])] = None
+  return url
+   
+class Url(object):
+  """Represents a URL and implements comparison logic.
+  
+  URL strings which are not identical can still be equivalent, so this object
+  provides a better interface for comparing and manipulating URLs than 
+  strings. URL parameters are represented as a dictionary of strings, and
+  defaults are used for the protocol (http) and port (80) if not provided.
+  """
+  def __init__(self, protocol=None, host=None, port=None, path=None, 
+               params=None):
+    self.protocol = protocol
+    self.host = host
+    self.port = port
+    self.path = path
+    self.params = params or {}
+
+  def to_string(self):
+    url_parts = ['', '', '', '', '', '']
+    if self.protocol:
+      url_parts[0] = self.protocol
+    if self.host:
+      if self.port:
+        url_parts[1] = ':'.join((self.host, str(self.port)))
+      else:
+        url_parts[1] = self.host
+    if self.path:
+      url_parts[2] = self.path
+    if self.params:
+      url_parts[4] = self.get_param_string()
+    return urlparse.urlunparse(url_parts)
+
+  def get_param_string(self):
+    param_pairs = []
+    for key, value in self.params.iteritems():
+      param_pairs.append('='.join((urllib.quote_plus(key), 
+          urllib.quote_plus(str(value)))))
+    return '&'.join(param_pairs)
+
+  def get_request_uri(self):
+    """Returns the path with the parameters escaped and appended."""
+    param_string = self.get_param_string()
+    if param_string:
+      return '?'.join([self.path, param_string])
+    else:
+      return self.path
+
+  def __cmp__(self, other):
+    if not isinstance(other, Url):
+      return cmp(self.to_string(), str(other))
+    difference = 0
+    # Compare the protocol
+    if self.protocol and other.protocol:
+      difference = cmp(self.protocol, other.protocol)
+    elif self.protocol and not other.protocol:
+      difference = cmp(self.protocol, DEFAULT_PROTOCOL)
+    elif not self.protocol and other.protocol:
+      difference = cmp(DEFAULT_PROTOCOL, other.protocol)
+    if difference != 0:
+      return difference
+    # Compare the host
+    difference = cmp(self.host, other.host)
+    if difference != 0:
+      return difference
+    # Compare the port
+    if self.port and other.port:
+      difference = cmp(self.port, other.port)
+    elif self.port and not other.port:
+      difference = cmp(self.port, DEFAULT_PORT)
+    elif not self.port and other.port:
+      difference = cmp(DEFAULT_PORT, other.port)
+    if difference != 0:
+      return difference
+    # Compare the path
+    difference = cmp(self.path, other.path)
+    if difference != 0:
+      return difference
+    # Compare the parameters
+    return cmp(self.params, other.params)
+
+  def __str__(self):
+    return self.to_string()
+    

blink/google/gdata/gauth.py

+#
+# Copyright (C) 2009 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# This module is used for version 2 of the Google Data APIs.
+
+
+"""Provides auth related token classes and functions for Google Data APIs.
+
+Token classes represent a user's authorization of this app to access their
+data. Usually these are not created directly but by a GDClient object.
+
+ClientLoginToken
+AuthSubToken
+SecureAuthSubToken
+OAuthHmacToken
+OAuthRsaToken
+TwoLeggedOAuthHmacToken
+TwoLeggedOAuthRsaToken
+
+Functions which are often used in application code (as opposed to just within
+the gdata-python-client library) are the following:
+
+generate_auth_sub_url
+authorize_request_token
+
+"""
+
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+import urllib
+
+
+PROGRAMMATIC_AUTH_LABEL = 'GoogleLogin auth='
+AUTHSUB_AUTH_LABEL = 'AuthSub token='
+
+
+# This dict provides the AuthSub and OAuth scopes for all services by service
+# name. The service name (key) is used in ClientLogin requests.
+AUTH_SCOPES = {
+    'cp': ( # Contacts API
+        'https://www.google.com/m8/feeds/',
+        'http://www.google.com/m8/feeds/')}
+
+
+
+class Error(Exception):
+  pass
+
+
+class UnsupportedTokenType(Error):
+  """Raised when token to or from blob is unable to convert the token."""
+  pass
+
+
+# ClientLogin functions and classes.
+def generate_client_login_request_body(email, password, service, source,
+    account_type='HOSTED_OR_GOOGLE', captcha_token=None,
+    captcha_response=None):
+  """Creates the body of the autentication request
+
+  See http://code.google.com/apis/accounts/AuthForInstalledApps.html#Request
+  for more details.
+
+  Args:
+    email: str
+    password: str
+    service: str
+    source: str
+    account_type: str (optional) Defaul is 'HOSTED_OR_GOOGLE', other valid
+        values are 'GOOGLE' and 'HOSTED'
+    captcha_token: str (optional)
+    captcha_response: str (optional)
+
+  Returns:
+    The HTTP body to send in a request for a client login token.
+  """
+  # Create a POST body containing the user's credentials.
+  request_fields = {'Email': email,
+                    'Passwd': password,
+                    'accountType': account_type,
+                    'service': service,
+                    'source': source}
+  if captcha_token and captcha_response:
+    # Send the captcha token and response as part of the POST body if the
+    # user is responding to a captch challenge.
+    request_fields['logintoken'] = captcha_token
+    request_fields['logincaptcha'] = captcha_response
+  return urllib.urlencode(request_fields)
+
+
+GenerateClientLoginRequestBody = generate_client_login_request_body
+
+
+def get_client_login_token_string(http_body):
+  """Returns the token value for a ClientLoginToken.
+
+  Reads the token from the server's response to a Client Login request and
+  creates the token value string to use in requests.
+
+  Args:
+    http_body: str The body of the server's HTTP response to a Client Login
+        request
+
+  Returns:
+    The token value string for a ClientLoginToken.
+  """
+  for response_line in http_body.splitlines():
+    if response_line.startswith('Auth='):
+      # Strip off the leading Auth= and return the Authorization value.
+      return response_line[5:]
+  return None
+
+
+GetClientLoginTokenString = get_client_login_token_string
+
+
+def get_captcha_challenge(http_body,
+    captcha_base_url='http://www.google.com/accounts/'):
+  """Returns the URL and token for a CAPTCHA challenge issued by the server.
+
+  Args:
+    http_body: str The body of the HTTP response from the server which
+        contains the CAPTCHA challenge.
+    captcha_base_url: str This function returns a full URL for viewing the
+        challenge image which is built from the server's response. This
+        base_url is used as the beginning of the URL because the server
+        only provides the end of the URL. For example the server provides
+        'Captcha?ctoken=Hi...N' and the URL for the image is
+        'http://www.google.com/accounts/Captcha?ctoken=Hi...N'
+
+  Returns:
+    A dictionary containing the information needed to repond to the CAPTCHA
+    challenge, the image URL and the ID token of the challenge. The
+    dictionary is in the form:
+    {'token': string identifying the CAPTCHA image,
+     'url': string containing the URL of the image}
+    Returns None if there was no CAPTCHA challenge in the response.
+  """
+  contains_captcha_challenge = False
+  captcha_parameters = {}
+  for response_line in http_body.splitlines():
+    if response_line.startswith('Error=CaptchaRequired'):
+      contains_captcha_challenge = True
+    elif response_line.startswith('CaptchaToken='):
+      # Strip off the leading CaptchaToken=
+      captcha_parameters['token'] = response_line[13:]
+    elif response_line.startswith('CaptchaUrl='):
+      captcha_parameters['url'] = '%s%s' % (captcha_base_url,
+          response_line[11:])
+  if contains_captcha_challenge:
+    return captcha_parameters
+  else:
+    return None
+
+
+GetCaptchaChallenge = get_captcha_challenge
+
+
+class ClientLoginToken(object):
+
+  def __init__(self, token_string):
+    self.token_string = token_string
+
+  def modify_request(self, http_request):
+    http_request.headers['Authorization'] = '%s%s' % (PROGRAMMATIC_AUTH_LABEL,
+        self.token_string)
+
+  ModifyRequest = modify_request
+
+
+
+def _join_token_parts(*args):
+  """"Escapes and combines all strings passed in.
+
+  Used to convert a token object's members into a string instead of
+  using pickle.
+
+  Note: A None value will be converted to an empty string.
+
+  Returns:
+    A string in the form 1x|member1|member2|member3...
+  """
+  return '|'.join([urllib.quote_plus(a or '') for a in args])
+
+
+def _split_token_parts(blob):
+  """Extracts and unescapes fields from the provided binary string.
+
+  Reverses the packing performed by _join_token_parts. Used to extract
+  the members of a token object.
+
+  Note: An empty string from the blob will be interpreted as None.
+
+  Args:
+    blob: str A string of the form 1x|member1|member2|member3 as created
+        by _join_token_parts
+
+  Returns:
+    A list of unescaped strings.
+  """
+  return [urllib.unquote_plus(part) or None for part in blob.split('|')]
+
+
+def token_to_blob(token):
+  """Serializes the token data as a string for storage in a datastore.
+
+  Supported token classes: ClientLoginToken, AuthSubToken, SecureAuthSubToken,
+  OAuthRsaToken, and OAuthHmacToken, TwoLeggedOAuthRsaToken,
+  TwoLeggedOAuthHmacToken.
+
+  Args:
+    token: A token object which must be of one of the supported token classes.
+
+  Raises:
+    UnsupportedTokenType if the token is not one of the supported token
+    classes listed above.
+
+  Returns:
+    A string represenging this token. The string can be converted back into
+    an equivalent token object using token_from_blob. Note that any members
+    which are set to '' will be set to None when the token is deserialized
+    by token_from_blob.
+  """
+  if isinstance(token, ClientLoginToken):
+    return _join_token_parts('1c', token.token_string)
+  else:
+    raise UnsupportedTokenType(
+        'Unable to serialize token of type %s' % type(token))
+
+
+TokenToBlob = token_to_blob
+
+
+def token_from_blob(blob):
+  """Deserializes a token string from the datastore back into a token object.
+
+  Supported token classes: ClientLoginToken, AuthSubToken, SecureAuthSubToken,
+  OAuthRsaToken, and OAuthHmacToken, TwoLeggedOAuthRsaToken,
+  TwoLeggedOAuthHmacToken.
+
+  Args:
+    blob: string created by token_to_blob.
+
+  Raises:
+    UnsupportedTokenType if the token is not one of the supported token
+    classes listed above.
+
+  Returns:
+    A new token object with members set to the values serialized in the
+    blob string. Note that any members which were set to '' in the original
+    token will now be None.
+  """
+  parts = _split_token_parts(blob)
+  if parts[0] == '1c':
+    return ClientLoginToken(parts[1])
+  else:
+    raise UnsupportedTokenType(
+        'Unable to deserialize token with type marker of %s' % parts[0])
+
+
+TokenFromBlob = token_from_blob
+
+
+def dump_tokens(tokens):
+  return ','.join([token_to_blob(t) for t in tokens])
+
+
+def load_tokens(blob):
+  return [token_from_blob(s) for s in blob.split(',')]
+
+
+def find_scopes_for_services(service_names=None):
+  """Creates a combined list of scope URLs for the desired services.
+
+  This method searches the AUTH_SCOPES dictionary.
+  
+  Args:
+    service_names: list of strings (optional) Each name must be a key in the
+                   AUTH_SCOPES dictionary. If no list is provided (None) then
+                   the resulting list will contain all scope URLs in the
+                   AUTH_SCOPES dict.
+
+  Returns:
+    A list of URL strings which are the scopes needed to access these services
+    when requesting a token using AuthSub or OAuth.
+  """
+  result_scopes = []
+  if service_names is None:
+    for service_name, scopes in AUTH_SCOPES.iteritems():
+      result_scopes.extend(scopes)
+  else:
+    for service_name in service_names:
+      result_scopes.extend(AUTH_SCOPES[service_name])
+  return result_scopes
+
+
+FindScopesForServices = find_scopes_for_services
+
+