Add existing GAM 3.21 code

gdata/analytics/calendar/client.py

@@ -0,0 +1,538 @@
+#!/usr/bin/python
+#
+# Copyright (C) 2011 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.
+
+"""CalendarClient extends the GDataService to streamline Google Calendar operations.
+
+  CalendarService: Provides methods to query feeds and manipulate items. Extends
+                GDataService.
+
+  DictionaryToParamList: Function which converts a dictionary into a list of
+                         URL arguments (represented as strings). This is a
+                         utility function used in CRUD operations.
+"""
+
+
+__author__ = 'alainv (Alain Vongsouvanh)'
+
+
+import urllib
+import gdata.client
+import gdata.calendar.data
+import atom.data
+import atom.http_core
+import gdata.gauth
+
+
+DEFAULT_BATCH_URL = ('https://www.google.com/calendar/feeds/default/private'
+                     '/full/batch')
+
+
+class CalendarClient(gdata.client.GDClient):
+  """Client for the Google Calendar service."""
+  api_version = '2'
+  auth_service = 'cl'
+  server = "www.google.com"
+  contact_list = "default"
+  auth_scopes = gdata.gauth.AUTH_SCOPES['cl']
+
+  def __init__(self, domain=None, auth_token=None, **kwargs):
+    """Constructs a new client for the Calendar API.
+
+    Args:
+      domain: string The Google Apps domain (if any).
+      kwargs: The other parameters to pass to the gdata.client.GDClient
+          constructor.
+    """
+    gdata.client.GDClient.__init__(self, auth_token=auth_token, **kwargs)
+    self.domain = domain
+
+  def get_calendar_feed_uri(self, feed='', projection='full', scheme="https"):
+    """Builds a feed URI.
+
+    Args:
+      projection: The projection to apply to the feed contents, for example
+        'full', 'base', 'base/12345', 'full/batch'. Default value: 'full'.
+      scheme: The URL scheme such as 'http' or 'https', None to return a
+          relative URI without hostname.
+
+    Returns:
+      A feed URI using the given scheme and projection.
+      Example: '/calendar/feeds/default/owncalendars/full'.
+    """
+    prefix = scheme and '%s://%s' % (scheme, self.server) or ''
+    suffix = feed and '/%s/%s' % (feed, projection) or ''
+    return '%s/calendar/feeds/default%s' % (prefix, suffix)
+
+  GetCalendarFeedUri = get_calendar_feed_uri
+
+  def get_calendar_event_feed_uri(self, calendar='default', visibility='private',
+                                  projection='full', scheme="https"):
+    """Builds a feed URI.
+
+    Args:
+      projection: The projection to apply to the feed contents, for example
+        'full', 'base', 'base/12345', 'full/batch'. Default value: 'full'.
+      scheme: The URL scheme such as 'http' or 'https', None to return a
+          relative URI without hostname.
+
+    Returns:
+      A feed URI using the given scheme and projection.
+      Example: '/calendar/feeds/default/private/full'.
+    """
+    prefix = scheme and '%s://%s' % (scheme, self.server) or ''
+    return '%s/calendar/feeds/%s/%s/%s' % (prefix, calendar,
+                                           visibility, projection)
+
+  GetCalendarEventFeedUri = get_calendar_event_feed_uri
+
+  def get_calendars_feed(self, uri,
+                         desired_class=gdata.calendar.data.CalendarFeed,
+                         auth_token=None, **kwargs):
+    """Obtains a calendar feed.
+
+    Args:
+      uri: The uri of the calendar feed to request.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarFeed.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.get_feed(uri, auth_token=auth_token,
+                         desired_class=desired_class, **kwargs)
+
+  GetCalendarsFeed = get_calendars_feed
+
+  def get_own_calendars_feed(self,
+                             desired_class=gdata.calendar.data.CalendarFeed,
+                             auth_token=None, **kwargs):
+    """Obtains a feed containing the calendars owned by the current user.
+
+    Args:
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarFeed.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.GetCalendarsFeed(uri=self.GetCalendarFeedUri(feed='owncalendars'),
+                                 desired_class=desired_class, auth_token=auth_token,
+                                 **kwargs)
+
+  GetOwnCalendarsFeed = get_own_calendars_feed
+
+  def get_all_calendars_feed(self, desired_class=gdata.calendar.data.CalendarFeed,
+                             auth_token=None, **kwargs):
+    """Obtains a feed containing all the ccalendars the current user has access to.
+
+    Args:
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarFeed.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.GetCalendarsFeed(uri=self.GetCalendarFeedUri(feed='allcalendars'),
+                                 desired_class=desired_class, auth_token=auth_token,
+                                 **kwargs)
+
+  GetAllCalendarsFeed = get_all_calendars_feed
+
+  def get_calendar_entry(self, uri, desired_class=gdata.calendar.data.CalendarEntry,
+                         auth_token=None, **kwargs):
+    """Obtains a single calendar entry.
+
+    Args:
+      uri: The uri of the desired calendar entry.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarEntry.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.get_entry(uri, auth_token=auth_token, desired_class=desired_class,
+                          **kwargs)
+
+  GetCalendarEntry = get_calendar_entry
+
+  def get_calendar_event_feed(self, uri=None,
+                              desired_class=gdata.calendar.data.CalendarEventFeed,
+               auth_token=None, **kwargs):
+    """Obtains a feed of events for the desired calendar.
+
+    Args:
+      uri: The uri of the desired calendar entry.
+           Defaults to https://www.google.com/calendar/feeds/default/private/full.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarEventFeed.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    uri = uri or self.GetCalendarEventFeedUri()
+    return self.get_feed(uri, auth_token=auth_token,
+                         desired_class=desired_class, **kwargs)
+
+  GetCalendarEventFeed = get_calendar_event_feed
+
+  def get_event_entry(self, uri, desired_class=gdata.calendar.data.CalendarEventEntry,
+              auth_token=None, **kwargs):
+    """Obtains a single event entry.
+
+    Args:
+      uri: The uri of the desired calendar event entry.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarEventEntry.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.get_entry(uri, auth_token=auth_token, desired_class=desired_class,
+                          **kwargs)
+
+  GetEventEntry = get_event_entry
+
+  def get_calendar_acl_feed(self, uri='https://www.google.com/calendar/feeds/default/acl/full',
+                            desired_class=gdata.calendar.data.CalendarAclFeed,
+                            auth_token=None, **kwargs):
+    """Obtains an Access Control List feed.
+
+    Args:
+      uri: The uri of the desired Acl feed.
+           Defaults to https://www.google.com/calendar/feeds/default/acl/full.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarAclFeed.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.get_feed(uri, auth_token=auth_token, desired_class=desired_class,
+                         **kwargs)
+
+  GetCalendarAclFeed = get_calendar_acl_feed
+
+  def get_calendar_acl_entry(self, uri, desired_class=gdata.calendar.data.CalendarAclEntry,
+                             auth_token=None, **kwargs):
+    """Obtains a single Access Control List entry.
+
+    Args:
+      uri: The uri of the desired Acl feed.
+      desired_class: class descended from atom.core.XmlElement to which a
+                     successful response should be converted. If there is no
+                     converter function specified (desired_class=None) then the
+                     desired_class will be used in calling the
+                     atom.core.parse function. If neither
+                     the desired_class nor the converter is specified, an
+                     HTTP reponse object will be returned. Defaults to
+                     gdata.calendar.data.CalendarAclEntry.
+      auth_token: An object which sets the Authorization HTTP header in its
+                  modify_request method. Recommended classes include
+                  gdata.gauth.ClientLoginToken and gdata.gauth.AuthSubToken
+                  among others. Represents the current user. Defaults to None
+                  and if None, this method will look for a value in the
+                  auth_token member of SpreadsheetsClient.
+    """
+    return self.get_entry(uri, auth_token=auth_token, desired_class=desired_class,
+                          **kwargs)
+
+  GetCalendarAclEntry = get_calendar_acl_entry
+
+  def insert_calendar(self, new_calendar, insert_uri=None, auth_token=None, **kwargs):
+    """Adds an new calendar to Google Calendar.
+
+    Args:
+      new_calendar: atom.Entry or subclass A new calendar which is to be added to
+                Google Calendar.
+      insert_uri: the URL to post new contacts to the feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the contact created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server,
+         'reason': HTTP reason from the server,
+         'body': HTTP body of the server's response}
+    """
+    insert_uri = insert_uri or self.GetCalendarFeedUri(feed='owncalendars')
+    return self.Post(new_calendar, insert_uri,
+                     auth_token=auth_token, **kwargs)
+
+  InsertCalendar = insert_calendar
+
+  def insert_calendar_subscription(self, calendar, insert_uri=None,
+                                   auth_token=None, **kwargs):
+    """Subscribes the authenticated user to the provided calendar.
+
+    Args:
+      calendar: The calendar to which the user should be subscribed.
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the subscription created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server,
+         'reason': HTTP reason from the server,
+         'body': HTTP body of the server's response}
+    """
+    insert_uri = insert_uri or self.GetCalendarFeedUri(feed='allcalendars')
+    return self.Post(calendar, insert_uri, auth_token=auth_token, **kwargs)
+
+  InsertCalendarSubscription = insert_calendar_subscription
+
+  def insert_event(self, new_event, insert_uri=None, auth_token=None, **kwargs):
+    """Adds an new event to Google Calendar.
+
+    Args:
+      new_event: atom.Entry or subclass A new event which is to be added to
+                Google Calendar.
+      insert_uri: the URL to post new contacts to the feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the contact created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server,
+         'reason': HTTP reason from the server,
+         'body': HTTP body of the server's response}
+    """
+    insert_uri = insert_uri or self.GetCalendarEventFeedUri()
+    return self.Post(new_event, insert_uri,
+                     auth_token=auth_token, **kwargs)
+
+
+  InsertEvent = insert_event
+
+  def insert_acl_entry(self, new_acl_entry,
+                       insert_uri = 'https://www.google.com/calendar/feeds/default/acl/full',
+                       auth_token=None, **kwargs):
+    """Adds an new Acl entry to Google Calendar.
+
+    Args:
+      new_acl_event: atom.Entry or subclass A new acl which is to be added to
+                Google Calendar.
+      insert_uri: the URL to post new contacts to the feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the contact created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server,
+         'reason': HTTP reason from the server,
+         'body': HTTP body of the server's response}
+    """
+    return self.Post(new_acl_entry, insert_uri, auth_token=auth_token, **kwargs)
+
+  InsertAclEntry = insert_acl_entry
+
+  def execute_batch(self, batch_feed, url, desired_class=None):
+    """Sends a batch request feed to the server.
+
+    Args:
+      batch_feed: gdata.contacts.CalendarEventFeed A feed containing batch
+          request entries. Each entry contains the operation to be performed
+          on the data contained in the entry. For example an entry with an
+          operation type of insert will be used as if the individual entry
+          had been inserted.
+      url: str The batch URL to which these operations should be applied.
+      converter: Function (optional) The function used to convert the server's
+          response to an object.
+
+    Returns:
+      The results of the batch request's execution on the server. If the
+      default converter is used, this is stored in a ContactsFeed.
+    """
+    return self.Post(batch_feed, url, desired_class=desired_class)
+
+  ExecuteBatch = execute_batch
+
+  def update(self, entry, auth_token=None, **kwargs):
+    """Edits the entry on the server by sending the XML for this entry.
+
+    Performs a PUT and converts the response to a new entry object with a
+    matching class to the entry passed in.
+
+    Args:
+      entry:
+      auth_token:
+
+    Returns:
+      A new Entry object of a matching type to the entry which was passed in.
+    """
+    return gdata.client.GDClient.Update(self, entry, auth_token=auth_token,
+                                        force=True, **kwargs)
+
+  Update = update
+
+
+class CalendarEventQuery(gdata.client.Query):
+  """
+  Create a custom Calendar Query
+
+  Full specs can be found at: U{Calendar query parameters reference
+  <http://code.google.com/apis/calendar/data/2.0/reference.html#Parameters>}
+  """
+
+  def __init__(self, feed=None, ctz=None, fields=None, futureevents=None,
+               max_attendees=None, orderby=None, recurrence_expansion_start=None,
+               recurrence_expansion_end=None, singleevents=None, showdeleted=None,
+               showhidden=None, sortorder=None, start_min=None, start_max=None,
+               updated_min=None, **kwargs):
+    """
+    @param max_results: The maximum number of entries to return. If you want
+        to receive all of the contacts, rather than only the default maximum, you
+        can specify a very large number for max-results.
+    @param start-index: The 1-based index of the first result to be retrieved.
+    @param updated-min: The lower bound on entry update dates.
+    @param group: Constrains the results to only the contacts belonging to the
+        group specified. Value of this parameter specifies group ID
+    @param orderby:  Sorting criterion. The only supported value is
+        lastmodified.
+    @param showdeleted: Include deleted contacts in the returned contacts feed
+    @pram sortorder: Sorting order direction. Can be either ascending or
+        descending.
+    @param requirealldeleted: Only relevant if showdeleted and updated-min
+        are also provided. It dictates the behavior of the server in case it
+        detects that placeholders of some entries deleted since the point in
+        time specified as updated-min may have been lost.
+    """
+    gdata.client.Query.__init__(self, **kwargs)
+    self.ctz = ctz
+    self.fields = fields
+    self.futureevents = futureevents
+    self.max_attendees = max_attendees
+    self.orderby = orderby
+    self.recurrence_expansion_start = recurrence_expansion_start
+    self.recurrence_expansion_end = recurrence_expansion_end
+    self.singleevents = singleevents
+    self.showdeleted = showdeleted
+    self.showhidden = showhidden
+    self.sortorder = sortorder
+    self.start_min = start_min
+    self.start_max = start_max
+    self.updated_min = updated_min
+
+  def modify_request(self, http_request):
+    if self.ctz:
+      gdata.client._add_query_param('ctz', self.ctz, http_request)
+    if self.fields:
+      gdata.client._add_query_param('fields', self.fields, http_request)
+    if self.futureevents:
+      gdata.client._add_query_param('futureevents', self.futureevents, http_request)
+    if self.max_attendees:
+      gdata.client._add_query_param('max-attendees', self.max_attendees, http_request)
+    if self.orderby:
+      gdata.client._add_query_param('orderby', self.orderby, http_request)
+    if self.recurrence_expansion_start:
+      gdata.client._add_query_param('recurrence-expansion-start',
+                                    self.recurrence_expansion_start, http_request)
+    if self.recurrence_expansion_end:
+      gdata.client._add_query_param('recurrence-expansion-end',
+                                    self.recurrence_expansion_end, http_request)
+    if self.singleevents:
+      gdata.client._add_query_param('singleevents', self.singleevents, http_request)
+    if self.showdeleted:
+      gdata.client._add_query_param('showdeleted', self.showdeleted, http_request)
+    if self.showhidden:
+      gdata.client._add_query_param('showhidden', self.showhidden, http_request)
+    if self.sortorder:
+      gdata.client._add_query_param('sortorder', self.sortorder, http_request)
+    if self.start_min:
+      gdata.client._add_query_param('start-min', self.start_min, http_request)
+    if self.start_max:
+      gdata.client._add_query_param('start-max', self.start_max, http_request)
+    if self.updated_min:
+      gdata.client._add_query_param('updated-min', self.updated_min, http_request)
+    gdata.client.Query.modify_request(self, http_request)
+
+  ModifyRequest = modify_request
+
+
+

gdata/analytics/calendar/data.py

@@ -0,0 +1,327 @@
+#!/usr/bin/python
+#
+# 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.
+
+
+"""Contains the data classes of the Google Calendar Data API"""
+
+
+__author__ = 'j.s@google.com (Jeff Scudder)'
+
+
+import atom.core
+import atom.data
+import gdata.acl.data
+import gdata.data
+import gdata.geo.data
+import gdata.opensearch.data
+
+
+GCAL_NAMESPACE = 'http://schemas.google.com/gCal/2005'
+GCAL_TEMPLATE = '{%s}%%s' % GCAL_NAMESPACE
+WEB_CONTENT_LINK_REL = '%s/%s' % (GCAL_NAMESPACE, 'webContent')
+
+
+class AccessLevelProperty(atom.core.XmlElement):
+  """Describes how much a given user may do with an event or calendar"""
+  _qname = GCAL_TEMPLATE % 'accesslevel'
+  value = 'value'
+
+
+class AllowGSync2Property(atom.core.XmlElement):
+  """Whether the user is permitted to run Google Apps Sync"""
+  _qname = GCAL_TEMPLATE % 'allowGSync2'
+  value = 'value'
+
+
+class AllowGSyncProperty(atom.core.XmlElement):
+  """Whether the user is permitted to run Google Apps Sync"""
+  _qname = GCAL_TEMPLATE % 'allowGSync'
+  value = 'value'
+
+
+class AnyoneCanAddSelfProperty(atom.core.XmlElement):
+  """Whether anyone can add self as attendee"""
+  _qname = GCAL_TEMPLATE % 'anyoneCanAddSelf'
+  value = 'value'
+
+
+class CalendarAclRole(gdata.acl.data.AclRole):
+  """Describes the Calendar roles of an entry in the Calendar access control list"""
+  _qname = gdata.acl.data.GACL_TEMPLATE % 'role'
+
+
+class CalendarCommentEntry(gdata.data.GDEntry):
+  """Describes an entry in a feed of a Calendar event's comments"""
+
+
+class CalendarCommentFeed(gdata.data.GDFeed):
+  """Describes feed of a Calendar event's comments"""
+  entry = [CalendarCommentEntry]
+
+
+class CalendarComments(gdata.data.Comments):
+  """Describes a container of a feed link for Calendar comment entries"""
+  _qname = gdata.data.GD_TEMPLATE % 'comments'
+
+
+class CalendarExtendedProperty(gdata.data.ExtendedProperty):
+  """Defines a value for the realm attribute that is used only in the calendar API"""
+  _qname = gdata.data.GD_TEMPLATE % 'extendedProperty'
+
+
+class CalendarWhere(gdata.data.Where):
+  """Extends the base Where class with Calendar extensions"""
+  _qname = gdata.data.GD_TEMPLATE % 'where'
+
+
+class ColorProperty(atom.core.XmlElement):
+  """Describes the color of a calendar"""
+  _qname = GCAL_TEMPLATE % 'color'
+  value = 'value'
+
+
+class GuestsCanInviteOthersProperty(atom.core.XmlElement):
+  """Whether guests can invite others to the event"""
+  _qname = GCAL_TEMPLATE % 'guestsCanInviteOthers'
+  value = 'value'
+
+
+class GuestsCanModifyProperty(atom.core.XmlElement):
+  """Whether guests can modify event"""
+  _qname = GCAL_TEMPLATE % 'guestsCanModify'
+  value = 'value'
+
+
+class GuestsCanSeeGuestsProperty(atom.core.XmlElement):
+  """Whether guests can see other attendees"""
+  _qname = GCAL_TEMPLATE % 'guestsCanSeeGuests'
+  value = 'value'
+
+
+class HiddenProperty(atom.core.XmlElement):
+  """Describes whether a calendar is hidden"""
+  _qname = GCAL_TEMPLATE % 'hidden'
+  value = 'value'
+
+
+class IcalUIDProperty(atom.core.XmlElement):
+  """Describes the UID in the ical export of the event"""
+  _qname = GCAL_TEMPLATE % 'uid'
+  value = 'value'
+
+
+class OverrideNameProperty(atom.core.XmlElement):
+  """Describes the override name property of a calendar"""
+  _qname = GCAL_TEMPLATE % 'overridename'
+  value = 'value'
+
+
+class PrivateCopyProperty(atom.core.XmlElement):
+  """Indicates whether this is a private copy of the event, changes to which should not be sent to other calendars"""
+  _qname = GCAL_TEMPLATE % 'privateCopy'
+  value = 'value'
+
+
+class QuickAddProperty(atom.core.XmlElement):
+  """Describes whether gd:content is for quick-add processing"""
+  _qname = GCAL_TEMPLATE % 'quickadd'
+  value = 'value'
+
+
+class ResourceProperty(atom.core.XmlElement):
+  """Describes whether gd:who is a resource such as a conference room"""
+  _qname = GCAL_TEMPLATE % 'resource'
+  value = 'value'
+  id = 'id'
+
+
+class EventWho(gdata.data.Who):
+  """Extends the base Who class with Calendar extensions"""
+  _qname = gdata.data.GD_TEMPLATE % 'who'
+  resource = ResourceProperty
+
+
+class SelectedProperty(atom.core.XmlElement):
+  """Describes whether a calendar is selected"""
+  _qname = GCAL_TEMPLATE % 'selected'
+  value = 'value'
+
+
+class SendAclNotificationsProperty(atom.core.XmlElement):
+  """Describes whether to send ACL notifications to grantees"""
+  _qname = GCAL_TEMPLATE % 'sendAclNotifications'
+  value = 'value'
+
+
+class CalendarAclEntry(gdata.acl.data.AclEntry):
+  """Describes an entry in a feed of a Calendar access control list (ACL)"""
+  send_acl_notifications = SendAclNotificationsProperty
+
+
+class CalendarAclFeed(gdata.data.GDFeed):
+  """Describes a Calendar access contorl list (ACL) feed"""
+  entry = [CalendarAclEntry]
+
+
+class SendEventNotificationsProperty(atom.core.XmlElement):
+  """Describes whether to send event notifications to other participants of the event"""
+  _qname = GCAL_TEMPLATE % 'sendEventNotifications'
+  value = 'value'
+
+
+class SequenceNumberProperty(atom.core.XmlElement):
+  """Describes sequence number of an event"""
+  _qname = GCAL_TEMPLATE % 'sequence'
+  value = 'value'
+
+
+class CalendarRecurrenceExceptionEntry(gdata.data.GDEntry):
+  """Describes an entry used by a Calendar recurrence exception entry link"""
+  uid = IcalUIDProperty
+  sequence = SequenceNumberProperty
+
+
+class CalendarRecurrenceException(gdata.data.RecurrenceException):
+  """Describes an exception to a recurring Calendar event"""
+  _qname = gdata.data.GD_TEMPLATE % 'recurrenceException'
+
+
+class SettingsProperty(atom.core.XmlElement):
+  """User preference name-value pair"""
+  _qname = GCAL_TEMPLATE % 'settingsProperty'
+  name = 'name'
+  value = 'value'
+
+
+class SettingsEntry(gdata.data.GDEntry):
+  """Describes a Calendar Settings property entry"""
+  settings_property = SettingsProperty
+
+
+class CalendarSettingsFeed(gdata.data.GDFeed):
+  """Personal settings for Calendar application"""
+  entry = [SettingsEntry]
+
+
+class SuppressReplyNotificationsProperty(atom.core.XmlElement):
+  """Lists notification methods to be suppressed for this reply"""
+  _qname = GCAL_TEMPLATE % 'suppressReplyNotifications'
+  methods = 'methods'
+
+
+class SyncEventProperty(atom.core.XmlElement):
+  """Describes whether this is a sync scenario where the Ical UID and Sequence number are honored during inserts and updates"""
+  _qname = GCAL_TEMPLATE % 'syncEvent'
+  value = 'value'
+
+
+class When(gdata.data.When):
+  """Extends the gd:when element to add reminders"""
+  reminder = [gdata.data.Reminder]
+
+
+class CalendarEventEntry(gdata.data.BatchEntry):
+  """Describes a Calendar event entry"""
+  quick_add = QuickAddProperty
+  send_event_notifications = SendEventNotificationsProperty
+  sync_event = SyncEventProperty
+  anyone_can_add_self = AnyoneCanAddSelfProperty
+  extended_property = [CalendarExtendedProperty]
+  sequence = SequenceNumberProperty
+  guests_can_invite_others = GuestsCanInviteOthersProperty
+  guests_can_modify = GuestsCanModifyProperty
+  guests_can_see_guests = GuestsCanSeeGuestsProperty
+  georss_where = gdata.geo.data.GeoRssWhere
+  private_copy = PrivateCopyProperty
+  suppress_reply_notifications = SuppressReplyNotificationsProperty
+  uid = IcalUIDProperty
+  where = [gdata.data.Where]
+  when = [When]
+  who = [gdata.data.Who]
+  transparency = gdata.data.Transparency
+  comments = gdata.data.Comments
+  event_status = gdata.data.EventStatus
+  visibility = gdata.data.Visibility
+  recurrence = gdata.data.Recurrence
+  recurrence_exception = [gdata.data.RecurrenceException]
+  original_event = gdata.data.OriginalEvent
+  reminder = [gdata.data.Reminder]
+
+
+class TimeZoneProperty(atom.core.XmlElement):
+  """Describes the time zone of a calendar"""
+  _qname = GCAL_TEMPLATE % 'timezone'
+  value = 'value'
+
+
+class TimesCleanedProperty(atom.core.XmlElement):
+  """Describes how many times calendar was cleaned via Manage Calendars"""
+  _qname = GCAL_TEMPLATE % 'timesCleaned'
+  value = 'value'
+
+
+class CalendarEntry(gdata.data.GDEntry):
+  """Describes a Calendar entry in the feed of a user's calendars"""
+  timezone = TimeZoneProperty
+  overridename = OverrideNameProperty
+  hidden = HiddenProperty
+  selected = SelectedProperty
+  times_cleaned = TimesCleanedProperty
+  color = ColorProperty
+  where = [CalendarWhere]
+  accesslevel = AccessLevelProperty
+
+
+class CalendarEventFeed(gdata.data.BatchFeed):
+  """Describes a Calendar event feed"""
+  allow_g_sync2 = AllowGSync2Property
+  timezone = TimeZoneProperty
+  entry = [CalendarEventEntry]
+  times_cleaned = TimesCleanedProperty
+  allow_g_sync = AllowGSyncProperty
+
+
+class CalendarFeed(gdata.data.GDFeed):
+  """Describes a feed of Calendars"""
+  entry = [CalendarEntry]
+
+
+class WebContentGadgetPref(atom.core.XmlElement):
+  """Describes a single web content gadget preference"""
+  _qname = GCAL_TEMPLATE % 'webContentGadgetPref'
+  name = 'name'
+  value = 'value'
+
+
+class WebContent(atom.core.XmlElement):
+  """Describes a "web content" extension"""
+  _qname = GCAL_TEMPLATE % 'webContent'
+  height = 'height'
+  width = 'width'
+  web_content_gadget_pref = [WebContentGadgetPref]
+  url = 'url'
+  display = 'display'
+
+
+class WebContentLink(atom.data.Link):
+  """Describes a "web content" link"""
+  def __init__(self, title=None, href=None, link_type=None,
+               web_content=None):
+    atom.data.Link.__init__(self, rel=WEB_CONTENT_LINK_REL, title=title, href=href,
+        link_type=link_type)
+
+  web_content = WebContent
+

gdata/analytics/calendar/service.py

@@ -0,0 +1,595 @@
+#!/usr/bin/python
+#
+# Copyright (C) 2006 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.
+
+"""CalendarService extends the GDataService to streamline Google Calendar operations.
+
+  CalendarService: Provides methods to query feeds and manipulate items. Extends 
+                GDataService.
+
+  DictionaryToParamList: Function which converts a dictionary into a list of 
+                         URL arguments (represented as strings). This is a 
+                         utility function used in CRUD operations.
+"""
+
+
+__author__ = 'api.vli (Vivian Li)'
+
+
+import urllib
+import gdata
+import atom.service
+import gdata.service
+import gdata.calendar
+import atom
+
+
+DEFAULT_BATCH_URL = ('http://www.google.com/calendar/feeds/default/private'
+                     '/full/batch')
+
+
+class Error(Exception):
+  pass
+
+
+class RequestError(Error):
+  pass
+
+
+class CalendarService(gdata.service.GDataService):
+  """Client for the Google Calendar service."""
+
+  def __init__(self, email=None, password=None, source=None,
+               server='www.google.com', additional_headers=None, **kwargs):
+    """Creates a client for the Google Calendar service.
+
+    Args:
+      email: string (optional) The user's email address, used for
+          authentication.
+      password: string (optional) The user's password.
+      source: string (optional) The name of the user's application.
+      server: string (optional) The name of the server to which a connection
+          will be opened. Default value: 'www.google.com'.
+      **kwargs: The other parameters to pass to gdata.service.GDataService
+          constructor.
+    """
+    gdata.service.GDataService.__init__(
+        self, email=email, password=password, service='cl', source=source,
+        server=server, additional_headers=additional_headers, **kwargs)
+
+  def GetCalendarEventFeed(self, uri='/calendar/feeds/default/private/full'):
+    return self.Get(uri, converter=gdata.calendar.CalendarEventFeedFromString)
+
+  def GetCalendarEventEntry(self, uri):
+    return self.Get(uri, converter=gdata.calendar.CalendarEventEntryFromString)
+
+  def GetCalendarListFeed(self, uri='/calendar/feeds/default/allcalendars/full'):
+    return self.Get(uri, converter=gdata.calendar.CalendarListFeedFromString)
+
+  def GetAllCalendarsFeed(self, uri='/calendar/feeds/default/allcalendars/full'):
+    return self.Get(uri, converter=gdata.calendar.CalendarListFeedFromString)
+
+  def GetOwnCalendarsFeed(self, uri='/calendar/feeds/default/owncalendars/full'):
+    return self.Get(uri, converter=gdata.calendar.CalendarListFeedFromString)
+
+  def GetCalendarListEntry(self, uri):
+    return self.Get(uri, converter=gdata.calendar.CalendarListEntryFromString)
+
+  def GetCalendarAclFeed(self, uri='/calendar/feeds/default/acl/full'):
+    return self.Get(uri, converter=gdata.calendar.CalendarAclFeedFromString)
+
+  def GetCalendarAclEntry(self, uri):
+    return self.Get(uri, converter=gdata.calendar.CalendarAclEntryFromString)
+
+  def GetCalendarEventCommentFeed(self, uri):
+    return self.Get(uri, converter=gdata.calendar.CalendarEventCommentFeedFromString)
+
+  def GetCalendarEventCommentEntry(self, uri):
+    return self.Get(uri, converter=gdata.calendar.CalendarEventCommentEntryFromString)
+ 
+  def Query(self, uri, converter=None):
+    """Performs a query and returns a resulting feed or entry.
+
+    Args:
+      feed: string The feed which is to be queried
+
+    Returns:
+      On success, a GDataFeed or Entry depending on which is sent from the 
+        server.
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    if converter:
+      result = self.Get(uri, converter=converter)
+    else:
+      result = self.Get(uri)
+    return result
+
+  def CalendarQuery(self, query):
+    if isinstance(query, CalendarEventQuery):
+      return self.Query(query.ToUri(), 
+          converter=gdata.calendar.CalendarEventFeedFromString)
+    elif isinstance(query, CalendarListQuery):
+      return self.Query(query.ToUri(), 
+          converter=gdata.calendar.CalendarListFeedFromString)
+    elif isinstance(query, CalendarEventCommentQuery):
+      return self.Query(query.ToUri(), 
+          converter=gdata.calendar.CalendarEventCommentFeedFromString)
+    else:
+      return self.Query(query.ToUri())
+    
+  def InsertEvent(self, new_event, insert_uri, url_params=None, 
+                  escape_params=True):
+    """Adds an event to Google Calendar.
+
+    Args: 
+      new_event: atom.Entry or subclass A new event which is to be added to 
+                Google Calendar.
+      insert_uri: the URL to post new events to the feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request. 
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the event created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    return self.Post(new_event, insert_uri, url_params=url_params,
+                     escape_params=escape_params, 
+                     converter=gdata.calendar.CalendarEventEntryFromString)
+
+  def InsertCalendarSubscription(self, calendar, url_params=None, 
+                                 escape_params=True):
+    """Subscribes the authenticated user to the provided calendar.
+    
+    Args: 
+      calendar: The calendar to which the user should be subscribed.
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request. 
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the subscription created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+    
+    insert_uri = '/calendar/feeds/default/allcalendars/full'
+    return self.Post(calendar, insert_uri, url_params=url_params,
+                     escape_params=escape_params, 
+                     converter=gdata.calendar.CalendarListEntryFromString)
+
+  def InsertCalendar(self, new_calendar, url_params=None,
+                                 escape_params=True):
+    """Creates a new calendar.
+    
+    Args: 
+      new_calendar: The calendar to be created
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request. 
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the calendar created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    insert_uri = '/calendar/feeds/default/owncalendars/full'
+    response = self.Post(new_calendar, insert_uri, url_params=url_params,
+                         escape_params=escape_params, 
+                         converter=gdata.calendar.CalendarListEntryFromString)
+    return response
+
+  def UpdateCalendar(self, calendar, url_params=None,
+                                 escape_params=True):
+    """Updates a calendar.
+    
+    Args: 
+      calendar: The calendar which should be updated
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request. 
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the calendar created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    update_uri = calendar.GetEditLink().href
+    response = self.Put(data=calendar, uri=update_uri, url_params=url_params,
+                         escape_params=escape_params,
+                         converter=gdata.calendar.CalendarListEntryFromString)
+    return response
+
+  def InsertAclEntry(self, new_entry, insert_uri, url_params=None, 
+                  escape_params=True):
+    """Adds an ACL entry (rule) to Google Calendar.
+
+    Args: 
+      new_entry: atom.Entry or subclass A new ACL entry which is to be added to 
+                Google Calendar.
+      insert_uri: the URL to post new entries to the ACL feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request. 
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the ACL entry created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    return self.Post(new_entry, insert_uri, url_params=url_params,
+                         escape_params=escape_params, 
+                         converter=gdata.calendar.CalendarAclEntryFromString)
+
+  def InsertEventComment(self, new_entry, insert_uri, url_params=None,
+                  escape_params=True):
+    """Adds an entry to Google Calendar.
+
+    Args:
+      new_entry: atom.Entry or subclass A new entry which is to be added to
+                Google Calendar.
+      insert_uri: the URL to post new entrys to the feed
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the insertion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful insert,  an entry containing the comment created
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    return self.Post(new_entry, insert_uri, url_params=url_params,
+        escape_params=escape_params, 
+        converter=gdata.calendar.CalendarEventCommentEntryFromString)
+
+  def _RemoveStandardUrlPrefix(self, url):
+    url_prefix = 'http://%s/' % self.server
+    if url.startswith(url_prefix):
+      return url[len(url_prefix) - 1:]
+    return url
+
+  def DeleteEvent(self, edit_uri, extra_headers=None, 
+      url_params=None, escape_params=True):
+    """Removes an event with the specified ID from Google Calendar.
+
+    Args:
+      edit_uri: string The edit URL of the entry to be deleted. Example:
+               'http://www.google.com/calendar/feeds/default/private/full/abx'
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the deletion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful delete,  a httplib.HTTPResponse containing the server's
+        response to the DELETE request.
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+    
+    edit_uri = self._RemoveStandardUrlPrefix(edit_uri)
+    return self.Delete('%s' % edit_uri,
+                       url_params=url_params, escape_params=escape_params)
+
+  def DeleteAclEntry(self, edit_uri, extra_headers=None, 
+      url_params=None, escape_params=True):
+    """Removes an ACL entry at the given edit_uri from Google Calendar.
+
+    Args:
+      edit_uri: string The edit URL of the entry to be deleted. Example:
+               'http://www.google.com/calendar/feeds/liz%40gmail.com/acl/full/default'
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the deletion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful delete,  a httplib.HTTPResponse containing the server's
+        response to the DELETE request.
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+   
+    edit_uri = self._RemoveStandardUrlPrefix(edit_uri)
+    return self.Delete('%s' % edit_uri,
+                       url_params=url_params, escape_params=escape_params)
+
+  def DeleteCalendarEntry(self, edit_uri, extra_headers=None,
+      url_params=None, escape_params=True):
+    """Removes a calendar entry at the given edit_uri from Google Calendar.
+
+    Args:
+      edit_uri: string The edit URL of the entry to be deleted. Example:
+               'http://www.google.com/calendar/feeds/default/allcalendars/abcdef@group.calendar.google.com'
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the deletion request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful delete, True is returned
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    return self.Delete(edit_uri, url_params=url_params, 
+                       escape_params=escape_params)
+
+  def UpdateEvent(self, edit_uri, updated_event, url_params=None, 
+                 escape_params=True):
+    """Updates an existing event.
+
+    Args:
+      edit_uri: string The edit link URI for the element being updated
+      updated_event: string, atom.Entry, or subclass containing
+                    the Atom Entry which will replace the event which is 
+                    stored at the edit_url 
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the update request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful update,  a httplib.HTTPResponse containing the server's
+        response to the PUT request.
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    edit_uri = self._RemoveStandardUrlPrefix(edit_uri)
+    return self.Put(updated_event, '%s' % edit_uri,
+                    url_params=url_params, 
+                    escape_params=escape_params, 
+                    converter=gdata.calendar.CalendarEventEntryFromString)
+
+  def UpdateAclEntry(self, edit_uri, updated_rule, url_params=None, 
+                     escape_params=True):
+    """Updates an existing ACL rule.
+
+    Args:
+      edit_uri: string The edit link URI for the element being updated
+      updated_rule: string, atom.Entry, or subclass containing
+                    the Atom Entry which will replace the event which is 
+                    stored at the edit_url 
+      url_params: dict (optional) Additional URL parameters to be included
+                  in the update request.
+      escape_params: boolean (optional) If true, the url_parameters will be
+                     escaped before they are included in the request.
+
+    Returns:
+      On successful update,  a httplib.HTTPResponse containing the server's
+        response to the PUT request.
+      On failure, a RequestError is raised of the form:
+        {'status': HTTP status code from server, 
+         'reason': HTTP reason from the server, 
+         'body': HTTP body of the server's response}
+    """
+
+    edit_uri = self._RemoveStandardUrlPrefix(edit_uri)
+    return self.Put(updated_rule, '%s' % edit_uri,
+                    url_params=url_params, 
+                    escape_params=escape_params,
+                    converter=gdata.calendar.CalendarAclEntryFromString)
+
+  def ExecuteBatch(self, batch_feed, url, 
+      converter=gdata.calendar.CalendarEventFeedFromString):
+    """Sends a batch request feed to the server.
+
+    The batch request needs to be sent to the batch URL for a particular 
+    calendar. You can find the URL by calling GetBatchLink().href on the 
+    CalendarEventFeed.
+
+    Args:
+      batch_feed: gdata.calendar.CalendarEventFeed A feed containing batch
+          request entries. Each entry contains the operation to be performed 
+          on the data contained in the entry. For example an entry with an 
+          operation type of insert will be used as if the individual entry 
+          had been inserted.
+      url: str The batch URL for the Calendar to which these operations should
+          be applied.
+      converter: Function (optional) The function used to convert the server's
+          response to an object. The default value is 
+          CalendarEventFeedFromString.
+     
+    Returns:
+      The results of the batch request's execution on the server. If the 
+      default converter is used, this is stored in a CalendarEventFeed.
+    """
+    return self.Post(batch_feed, url, converter=converter)
+
+
+class CalendarEventQuery(gdata.service.Query):
+
+  def __init__(self, user='default', visibility='private', projection='full',
+               text_query=None, params=None, categories=None):
+    gdata.service.Query.__init__(self, 
+        feed='http://www.google.com/calendar/feeds/%s/%s/%s' % (
+            urllib.quote(user), 
+            urllib.quote(visibility), 
+            urllib.quote(projection)),
+        text_query=text_query, params=params, categories=categories)
+    
+  def _GetStartMin(self):
+    if 'start-min' in self.keys():
+      return self['start-min']
+    else:
+      return None
+
+  def _SetStartMin(self, val):
+    self['start-min'] = val
+
+  start_min = property(_GetStartMin, _SetStartMin, 
+      doc="""The start-min query parameter""")
+
+  def _GetStartMax(self):
+    if 'start-max' in self.keys():
+      return self['start-max']
+    else:
+      return None
+
+  def _SetStartMax(self, val):
+    self['start-max'] = val
+
+  start_max = property(_GetStartMax, _SetStartMax, 
+      doc="""The start-max query parameter""")
+
+  def _GetOrderBy(self):
+    if 'orderby' in self.keys():
+      return self['orderby']
+    else:
+      return None
+
+  def _SetOrderBy(self, val):
+    if val is not 'lastmodified' and val is not 'starttime':
+      raise Error, "Order By must be either 'lastmodified' or 'starttime'"
+    self['orderby'] = val
+
+  orderby = property(_GetOrderBy, _SetOrderBy, 
+      doc="""The orderby query parameter""")
+
+  def _GetSortOrder(self):
+    if 'sortorder' in self.keys():
+      return self['sortorder']
+    else:
+      return None
+
+  def _SetSortOrder(self, val):
+    if (val is not 'ascending' and val is not 'descending' 
+        and val is not 'a' and val is not 'd' and val is not 'ascend'
+        and val is not 'descend'):
+      raise Error, "Sort order must be either ascending, ascend, " + (
+          "a or descending, descend, or d")
+    self['sortorder'] = val
+
+  sortorder = property(_GetSortOrder, _SetSortOrder, 
+      doc="""The sortorder query parameter""")
+
+  def _GetSingleEvents(self):
+    if 'singleevents' in self.keys():
+      return self['singleevents']
+    else:
+      return None
+
+  def _SetSingleEvents(self, val):
+    self['singleevents'] = val
+
+  singleevents = property(_GetSingleEvents, _SetSingleEvents, 
+      doc="""The singleevents query parameter""")
+
+  def _GetFutureEvents(self):
+    if 'futureevents' in self.keys():
+      return self['futureevents']
+    else:
+      return None
+
+  def _SetFutureEvents(self, val):
+    self['futureevents'] = val
+
+  futureevents = property(_GetFutureEvents, _SetFutureEvents, 
+      doc="""The futureevents query parameter""")
+
+  def _GetRecurrenceExpansionStart(self):
+    if 'recurrence-expansion-start' in self.keys():
+      return self['recurrence-expansion-start']
+    else:
+      return None
+
+  def _SetRecurrenceExpansionStart(self, val):
+    self['recurrence-expansion-start'] = val
+
+  recurrence_expansion_start = property(_GetRecurrenceExpansionStart, 
+      _SetRecurrenceExpansionStart, 
+      doc="""The recurrence-expansion-start query parameter""")
+
+  def _GetRecurrenceExpansionEnd(self):
+    if 'recurrence-expansion-end' in self.keys():
+      return self['recurrence-expansion-end']
+    else:
+      return None
+
+  def _SetRecurrenceExpansionEnd(self, val):
+    self['recurrence-expansion-end'] = val
+
+  recurrence_expansion_end = property(_GetRecurrenceExpansionEnd, 
+      _SetRecurrenceExpansionEnd, 
+      doc="""The recurrence-expansion-end query parameter""")
+
+  def _SetTimezone(self, val):
+    self['ctz'] = val
+
+  def _GetTimezone(self):
+    if 'ctz' in self.keys():
+      return self['ctz']
+    else:
+      return None
+
+  ctz = property(_GetTimezone, _SetTimezone, 
+      doc="""The ctz query parameter which sets report time on the server.""")
+
+
+class CalendarListQuery(gdata.service.Query): 
+  """Queries the Google Calendar meta feed"""
+
+  def __init__(self, userId=None, text_query=None,
+               params=None, categories=None):
+    if userId is None:
+      userId = 'default'
+
+    gdata.service.Query.__init__(self, feed='http://www.google.com/calendar/feeds/'
+                           +userId,
+                           text_query=text_query, params=params,
+                           categories=categories)
+
+class CalendarEventCommentQuery(gdata.service.Query): 
+  """Queries the Google Calendar event comments feed"""
+
+  def __init__(self, feed=None):
+    gdata.service.Query.__init__(self, feed=feed)