- 1 # Copyright 2016 Google Inc. All Rights Reserved. - 2 # - 3 # Licensed under the Apache License, Version 2.0 (the "License"); - 4 # you may not use this file except in compliance with the License. - 5 # You may obtain a copy of the License at - 6 # - 7 # http://www.apache.org/licenses/LICENSE-2.0 - 8 # - 9 # Unless required by applicable law or agreed to in writing, software -10 # distributed under the License is distributed on an "AS IS" BASIS, -11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -12 # See the License for the specific language governing permissions and -13 # limitations under the License. -14 -15 """Helpers for authentication using oauth2client or google-auth.""" -16 -17 try: -18 import google.auth -19 import google.auth.credentials -20 import google_auth_httplib2 -21 HAS_GOOGLE_AUTH = True -22 except ImportError: # pragma: NO COVER -23 HAS_GOOGLE_AUTH = False -24 -25 try: -26 import oauth2client -27 import oauth2client.client -28 HAS_OAUTH2CLIENT = True -29 except ImportError: # pragma: NO COVER -30 HAS_OAUTH2CLIENT = False -31 -32 from googleapiclient.http import build_http -33 -34 -

35 -def default_credentials(): -

36 """Returns Application Default Credentials.""" -37 if HAS_GOOGLE_AUTH: -38 credentials, _ = google.auth.default() -39 return credentials -40 elif HAS_OAUTH2CLIENT: -41 return oauth2client.client.GoogleCredentials.get_application_default() -42 else: -43 raise EnvironmentError( -44 'No authentication library is available. Please install either ' -45 'google-auth or oauth2client.') -

46 -47 -

48 -def with_scopes(credentials, scopes): -

49 """Scopes the credentials if necessary. -50 -51 Args: -52 credentials (Union[ -53 google.auth.credentials.Credentials, -54 oauth2client.client.Credentials]): The credentials to scope. -55 scopes (Sequence[str]): The list of scopes. -56 -57 Returns: -58 Union[google.auth.credentials.Credentials, -59 oauth2client.client.Credentials]: The scoped credentials. -60 """ -61 if HAS_GOOGLE_AUTH and isinstance( -62 credentials, google.auth.credentials.Credentials): -63 return google.auth.credentials.with_scopes_if_required( -64 credentials, scopes) -65 else: -66 try: -67 if credentials.create_scoped_required(): -68 return credentials.create_scoped(scopes) -69 else: -70 return credentials -71 except AttributeError: -72 return credentials -

73 -74 -

75 -def authorized_http(credentials): -

76 """Returns an http client that is authorized with the given credentials. -77 -78 Args: -79 credentials (Union[ -80 google.auth.credentials.Credentials, -81 oauth2client.client.Credentials]): The credentials to use. -82 -83 Returns: -84 Union[httplib2.Http, google_auth_httplib2.AuthorizedHttp]: An -85 authorized http client. -86 """ -87 if HAS_GOOGLE_AUTH and isinstance( -88 credentials, google.auth.credentials.Credentials): -89 return google_auth_httplib2.AuthorizedHttp(credentials, -90 http=build_http()) -91 else: -92 return credentials.authorize(build_http()) -

93 + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + Package googleapiclient :: + Module _helpers + +

+ + + + +

[hide private]

[frames] | no frames]

+ +

Module _helpers

source code

+Helper functions for commonly used utilities.
+
+

+ + + + + + + + + + + + + + + + + + + +

+ + + + + +

Functions

[hide private]

+ +

+ + + + + +

positional(max_positional_args)
+ A decorator to declare that only the first N arguments my be positional.

+ source code + +

+ +

+ + + + + +

parse_unique_urlencoded(content)
+ Parses unique key-value parameters from urlencoded content.

+ source code + +

+ +

+ + + + + +

update_query_params(uri, + params)
+ Updates a URI with new query parameters.

+ source code + +

+ +

+ + + + + +

_add_query_parameter(url, + name, + value)
+ Adds a query parameter to a url.

+ source code + +

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + +

Variables

[hide private]

+ + + logger = logging.getLogger(__name__) +

+ + + POSITIONAL_WARNING = 'WARNING' +

+ + + POSITIONAL_EXCEPTION = 'EXCEPTION' +

+ + + POSITIONAL_IGNORE = 'IGNORE' +

+ + + POSITIONAL_SET = frozenset([POSITIONAL_WARNING, POSITIONAL_EXC... +

+ + + positional_parameters_enforcement = 'WARNING' +

+ + + _SYM_LINK_MESSAGE = 'File: {0}: Is a symbolic link.' +

+ + + _IS_DIR_MESSAGE = '{0}: Is a directory' +

+ + + _MISSING_FILE_MESSAGE = 'Cannot access {0}: No such file or di... +

+ + + + + + +

+ + + + + +

Function Details

[hide private]

+ +

+ + +

positional(max_positional_args) +

source code +

+ +

+A decorator to declare that only the first N arguments my be positional.
+
+This decorator makes it easy to support Python 3 style keyword-only
+parameters. For example, in Python 3 it is possible to write::
+
+    def fn(pos1, *, kwonly1=None, kwonly1=None):
+        ...
+
+All named parameters after ``*`` must be a keyword::
+
+    fn(10, 'kw1', 'kw2')  # Raises exception.
+    fn(10, kwonly1='kw1')  # Ok.
+
+Example
+^^^^^^^
+
+To define a function like above, do::
+
+    @positional(1)
+    def fn(pos1, kwonly1=None, kwonly2=None):
+        ...
+
+If no default value is provided to a keyword argument, it becomes a
+required keyword argument::
+
+    @positional(0)
+    def fn(required_kw):
+        ...
+
+This must be called with the keyword parameter::
+
+    fn()  # Raises exception.
+    fn(10)  # Raises exception.
+    fn(required_kw=10)  # Ok.
+
+When defining instance or class methods always remember to account for
+``self`` and ``cls``::
+
+    class MyClass(object):
+
+        @positional(2)
+        def my_method(self, pos1, kwonly1=None):
+            ...
+
+        @classmethod
+        @positional(2)
+        def my_method(cls, pos1, kwonly1=None):
+            ...
+
+The positional decorator behavior is controlled by
+``_helpers.positional_parameters_enforcement``, which may be set to
+``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or
+``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do
+nothing, respectively, if a declaration is violated.
+
+Args:
+    max_positional_arguments: Maximum number of positional arguments. All
+                              parameters after the this index must be
+                              keyword only.
+
+Returns:
+    A decorator that prevents using arguments after max_positional_args
+    from being used as positional parameters.
+
+Raises:
+    TypeError: if a key-word only argument is provided as a positional
+               parameter, but only if
+               _helpers.positional_parameters_enforcement is set to
+               POSITIONAL_EXCEPTION.
+
+

+ +

+ + +

parse_unique_urlencoded(content) +

source code +

+ +

+Parses unique key-value parameters from urlencoded content.
+
+Args:
+    content: string, URL-encoded key-value pairs.
+
+Returns:
+    dict, The key-value pairs from ``content``.
+
+Raises:
+    ValueError: if one of the keys is repeated.
+
+

+ +

+ + +

update_query_params(uri, + params) +

source code +

+ +

+Updates a URI with new query parameters.
+
+If a given key from ``params`` is repeated in the ``uri``, then
+the URI will be considered invalid and an error will occur.
+
+If the URI is valid, then each value from ``params`` will
+replace the corresponding value in the query parameters (if
+it exists).
+
+Args:
+    uri: string, A valid URI, with potential existing query parameters.
+    params: dict, A dictionary of query parameters.
+
+Returns:
+    The same URI but with the new query parameters added.
+
+

+ +

+ + +

_add_query_parameter(url, + name, + value) +

source code +

+ +

+Adds a query parameter to a url.
+
+Replaces the current value if it already exists in the URL.
+
+Args:
+    url: string, url to add the query parameter to.
+    name: string, query parameter name.
+    value: string, query parameter value.
+
+Returns:
+    Updated query parameter. Does not update the url if value is None.
+
+

+ +

+
+ + + + + + +

+ + + + + +

Variables Details

[hide private]

+ +

POSITIONAL_SET

+ +

Value:

+frozenset([POSITIONAL_WARNING, POSITIONAL_EXCEPTION, POSITIONAL_IGNORE
+])
+

+ +

_MISSING_FILE_MESSAGE

+ +

Value:

+'Cannot access {0}: No such file or directory'
+

+
+ + + + + + + + + + + + + + + + + + + + + + + +

+ + + + diff --git a/docs/epy/googleapiclient._helpers-pysrc.html b/docs/epy/googleapiclient._helpers-pysrc.html new file mode 100644 index 00000000000..3d6ae05c64d --- /dev/null +++ b/docs/epy/googleapiclient._helpers-pysrc.html @@ -0,0 +1,317 @@ + + + + + googleapiclient._helpers + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + Package googleapiclient :: + Module _helpers + +

+ + + + +

[hide private]

[frames] | no frames]

Source Code for Module googleapiclient._helpers

+  1  # Copyright 2015 Google Inc. All rights reserved. 
+  2  # 
+  3  # Licensed under the Apache License, Version 2.0 (the "License"); 
+  4  # you may not use this file except in compliance with the License. 
+  5  # You may obtain a copy of the License at 
+  6  # 
+  7  #      http://www.apache.org/licenses/LICENSE-2.0 
+  8  # 
+  9  # Unless required by applicable law or agreed to in writing, software 
+ 10  # distributed under the License is distributed on an "AS IS" BASIS, 
+ 11  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ 12  # See the License for the specific language governing permissions and 
+ 13  # limitations under the License. 
+ 14   
+ 15  """Helper functions for commonly used utilities.""" 
+ 16   
+ 17  import functools 
+ 18  import inspect 
+ 19  import logging 
+ 20  import warnings 
+ 21   
+ 22  import six 
+ 23  from six.moves import urllib 
+ 24   
+ 25   
+ 26  logger = logging.getLogger(__name__) 
+ 27   
+ 28  POSITIONAL_WARNING = 'WARNING' 
+ 29  POSITIONAL_EXCEPTION = 'EXCEPTION' 
+ 30  POSITIONAL_IGNORE = 'IGNORE' 
+ 31  POSITIONAL_SET = frozenset([POSITIONAL_WARNING, POSITIONAL_EXCEPTION, 
+ 32                              POSITIONAL_IGNORE]) 
+ 33   
+ 34  positional_parameters_enforcement = POSITIONAL_WARNING 
+ 35   
+ 36  _SYM_LINK_MESSAGE = 'File: {0}: Is a symbolic link.' 
+ 37  _IS_DIR_MESSAGE = '{0}: Is a directory' 
+ 38  _MISSING_FILE_MESSAGE = 'Cannot access {0}: No such file or directory' 
+ 39   
+ 40   
+ 41 -def positional(max_positional_args): 
+
 42      """A decorator to declare that only the first N arguments my be positional. 
+ 43   
+ 44      This decorator makes it easy to support Python 3 style keyword-only 
+ 45      parameters. For example, in Python 3 it is possible to write:: 
+ 46   
+ 47          def fn(pos1, *, kwonly1=None, kwonly1=None): 
+ 48              ... 
+ 49   
+ 50      All named parameters after ``*`` must be a keyword:: 
+ 51   
+ 52          fn(10, 'kw1', 'kw2')  # Raises exception. 
+ 53          fn(10, kwonly1='kw1')  # Ok. 
+ 54   
+ 55      Example 
+ 56      ^^^^^^^ 
+ 57   
+ 58      To define a function like above, do:: 
+ 59   
+ 60          @positional(1) 
+ 61          def fn(pos1, kwonly1=None, kwonly2=None): 
+ 62              ... 
+ 63   
+ 64      If no default value is provided to a keyword argument, it becomes a 
+ 65      required keyword argument:: 
+ 66   
+ 67          @positional(0) 
+ 68          def fn(required_kw): 
+ 69              ... 
+ 70   
+ 71      This must be called with the keyword parameter:: 
+ 72   
+ 73          fn()  # Raises exception. 
+ 74          fn(10)  # Raises exception. 
+ 75          fn(required_kw=10)  # Ok. 
+ 76   
+ 77      When defining instance or class methods always remember to account for 
+ 78      ``self`` and ``cls``:: 
+ 79   
+ 80          class MyClass(object): 
+ 81   
+ 82              @positional(2) 
+ 83              def my_method(self, pos1, kwonly1=None): 
+ 84                  ... 
+ 85   
+ 86              @classmethod 
+ 87              @positional(2) 
+ 88              def my_method(cls, pos1, kwonly1=None): 
+ 89                  ... 
+ 90   
+ 91      The positional decorator behavior is controlled by 
+ 92      ``_helpers.positional_parameters_enforcement``, which may be set to 
+ 93      ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or 
+ 94      ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do 
+ 95      nothing, respectively, if a declaration is violated. 
+ 96   
+ 97      Args: 
+ 98          max_positional_arguments: Maximum number of positional arguments. All 
+ 99                                    parameters after the this index must be 
+100                                    keyword only. 
+101   
+102      Returns: 
+103          A decorator that prevents using arguments after max_positional_args 
+104          from being used as positional parameters. 
+105   
+106      Raises: 
+107          TypeError: if a key-word only argument is provided as a positional 
+108                     parameter, but only if 
+109                     _helpers.positional_parameters_enforcement is set to 
+110                     POSITIONAL_EXCEPTION. 
+111      """ 
+112   
+113      def positional_decorator(wrapped): 
+114          @functools.wraps(wrapped) 
+115          def positional_wrapper(*args, **kwargs): 
+116              if len(args) > max_positional_args: 
+117                  plural_s = '' 
+118                  if max_positional_args != 1: 
+119                      plural_s = 's' 
+120                  message = ('{function}() takes at most {args_max} positional ' 
+121                             'argument{plural} ({args_given} given)'.format( 
+122                                 function=wrapped.__name__, 
+123                                 args_max=max_positional_args, 
+124                                 args_given=len(args), 
+125                                 plural=plural_s)) 
+126                  if positional_parameters_enforcement == POSITIONAL_EXCEPTION: 
+127                      raise TypeError(message) 
+128                  elif positional_parameters_enforcement == POSITIONAL_WARNING: 
+129                      logger.warning(message) 
+130              return wrapped(*args, **kwargs) 
+
131          return positional_wrapper 
+132   
+133      if isinstance(max_positional_args, six.integer_types): 
+134          return positional_decorator 
+135      else: 
+136          args, _, _, defaults = inspect.getargspec(max_positional_args) 
+137          return positional(len(args) - len(defaults))(max_positional_args) 
+138   
+139   
+140 -def parse_unique_urlencoded(content): 
+
141      """Parses unique key-value parameters from urlencoded content. 
+142   
+143      Args: 
+144          content: string, URL-encoded key-value pairs. 
+145   
+146      Returns: 
+147          dict, The key-value pairs from ``content``. 
+148   
+149      Raises: 
+150          ValueError: if one of the keys is repeated. 
+151      """ 
+152      urlencoded_params = urllib.parse.parse_qs(content) 
+153      params = {} 
+154      for key, value in six.iteritems(urlencoded_params): 
+155          if len(value) != 1: 
+156              msg = ('URL-encoded content contains a repeated value:' 
+157                     '%s -> %s' % (key, ', '.join(value))) 
+158              raise ValueError(msg) 
+159          params[key] = value[0] 
+160      return params 
+
161   
+162   
+163 -def update_query_params(uri, params): 
+
164      """Updates a URI with new query parameters. 
+165   
+166      If a given key from ``params`` is repeated in the ``uri``, then 
+167      the URI will be considered invalid and an error will occur. 
+168   
+169      If the URI is valid, then each value from ``params`` will 
+170      replace the corresponding value in the query parameters (if 
+171      it exists). 
+172   
+173      Args: 
+174          uri: string, A valid URI, with potential existing query parameters. 
+175          params: dict, A dictionary of query parameters. 
+176   
+177      Returns: 
+178          The same URI but with the new query parameters added. 
+179      """ 
+180      parts = urllib.parse.urlparse(uri) 
+181      query_params = parse_unique_urlencoded(parts.query) 
+182      query_params.update(params) 
+183      new_query = urllib.parse.urlencode(query_params) 
+184      new_parts = parts._replace(query=new_query) 
+185      return urllib.parse.urlunparse(new_parts) 
+
186   
+187   
+188 -def _add_query_parameter(url, name, value): 
+
189      """Adds a query parameter to a url. 
+190   
+191      Replaces the current value if it already exists in the URL. 
+192   
+193      Args: 
+194          url: string, url to add the query parameter to. 
+195          name: string, query parameter name. 
+196          value: string, query parameter value. 
+197   
+198      Returns: 
+199          Updated query parameter. Does not update the url if value is None. 
+200      """ 
+201      if value is None: 
+202          return url 
+203      else: 
+204          return update_query_params(url, {name: value}) 
+
205   
+

+
+ + + + + + + + + + + + + + + + + + + + + + + +

+ + + + diff --git a/docs/epy/googleapiclient.channel-module.html b/docs/epy/googleapiclient.channel-module.html index af1394f51b5..27484dafad3 100644 --- a/docs/epy/googleapiclient.channel-module.html +++ b/docs/epy/googleapiclient.channel-module.html @@ -455,7 +455,7 @@

CHANNEL_PARAMS

- Generated by Epydoc 3.0.1 on Mon Jun 5 13:38:39 2017 + Generated by Epydoc 3.0.1 on Fri Jun 14 13:09:01 2019

Source Code for Module googleapiclient.channel

-  1  """Channel notifications support. 
-  2   
-  3  Classes and functions to support channel subscriptions and notifications 
-  4  on those channels. 
-  5   
-  6  Notes: 
-  7    - This code is based on experimental APIs and is subject to change. 
-  8    - Notification does not do deduplication of notification ids, that's up to 
-  9      the receiver. 
- 10    - Storing the Channel between calls is up to the caller. 
- 11   
- 12   
- 13  Example setting up a channel: 
- 14   
- 15    # Create a new channel that gets notifications via webhook. 
- 16    channel = new_webhook_channel("https://example.com/my_web_hook") 
- 17   
- 18    # Store the channel, keyed by 'channel.id'. Store it before calling the 
- 19    # watch method because notifications may start arriving before the watch 
- 20    # method returns. 
- 21    ... 
- 22   
- 23    resp = service.objects().watchAll( 
- 24      bucket="some_bucket_id", body=channel.body()).execute() 
- 25    channel.update(resp) 
+  1  # Copyright 2014 Google Inc. All Rights Reserved. 
+  2  # 
+  3  # Licensed under the Apache License, Version 2.0 (the "License"); 
+  4  # you may not use this file except in compliance with the License. 
+  5  # You may obtain a copy of the License at 
+  6  # 
+  7  #      http://www.apache.org/licenses/LICENSE-2.0 
+  8  # 
+  9  # Unless required by applicable law or agreed to in writing, software 
+ 10  # distributed under the License is distributed on an "AS IS" BASIS, 
+ 11  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ 12  # See the License for the specific language governing permissions and 
+ 13  # limitations under the License. 
+ 14   
+ 15  """Channel notifications support. 
+ 16   
+ 17  Classes and functions to support channel subscriptions and notifications 
+ 18  on those channels. 
+ 19   
+ 20  Notes: 
+ 21    - This code is based on experimental APIs and is subject to change. 
+ 22    - Notification does not do deduplication of notification ids, that's up to 
+ 23      the receiver. 
+ 24    - Storing the Channel between calls is up to the caller. 
+ 25   
  26   
- 27    # Store the channel, keyed by 'channel.id'. Store it after being updated 
- 28    # since the resource_id value will now be correct, and that's needed to 
- 29    # stop a subscription. 
- 30    ... 
+ 27  Example setting up a channel: 
+ 28   
+ 29    # Create a new channel that gets notifications via webhook. 
+ 30    channel = new_webhook_channel("https://example.com/my_web_hook") 
  31   
- 32   
- 33  An example Webhook implementation using webapp2. Note that webapp2 puts 
- 34  headers in a case insensitive dictionary, as headers aren't guaranteed to 
- 35  always be upper case. 
+ 32    # Store the channel, keyed by 'channel.id'. Store it before calling the 
+ 33    # watch method because notifications may start arriving before the watch 
+ 34    # method returns. 
+ 35    ... 
  36   
- 37    id = self.request.headers[X_GOOG_CHANNEL_ID] 
- 38   
- 39    # Retrieve the channel by id. 
- 40    channel = ... 
- 41   
- 42    # Parse notification from the headers, including validating the id. 
- 43    n = notification_from_headers(channel, self.request.headers) 
- 44   
- 45    # Do app specific stuff with the notification here. 
- 46    if n.resource_state == 'sync': 
- 47      # Code to handle sync state. 
- 48    elif n.resource_state == 'exists': 
- 49      # Code to handle the exists state. 
- 50    elif n.resource_state == 'not_exists': 
- 51      # Code to handle the not exists state. 
+ 37    resp = service.objects().watchAll( 
+ 38      bucket="some_bucket_id", body=channel.body()).execute() 
+ 39    channel.update(resp) 
+ 40   
+ 41    # Store the channel, keyed by 'channel.id'. Store it after being updated 
+ 42    # since the resource_id value will now be correct, and that's needed to 
+ 43    # stop a subscription. 
+ 44    ... 
+ 45   
+ 46   
+ 47  An example Webhook implementation using webapp2. Note that webapp2 puts 
+ 48  headers in a case insensitive dictionary, as headers aren't guaranteed to 
+ 49  always be upper case. 
+ 50   
+ 51    id = self.request.headers[X_GOOG_CHANNEL_ID] 
  52   
- 53   
- 54  Example of unsubscribing. 
+ 53    # Retrieve the channel by id. 
+ 54    channel = ... 
  55   
- 56    service.channels().stop(channel.body()) 
- 57  """ 
- 58  from __future__ import absolute_import 
- 59   
- 60  import datetime 
- 61  import uuid 
- 62   
- 63  from googleapiclient import errors 
- 64  import six 
- 65   
- 66  # Oauth2client < 3 has the positional helper in 'util', >= 3 has it 
- 67  # in '_helpers'. 
- 68  try: 
- 69    from oauth2client import util 
- 70  except ImportError: 
- 71    from oauth2client import _helpers as util 
- 72   
+ 56    # Parse notification from the headers, including validating the id. 
+ 57    n = notification_from_headers(channel, self.request.headers) 
+ 58   
+ 59    # Do app specific stuff with the notification here. 
+ 60    if n.resource_state == 'sync': 
+ 61      # Code to handle sync state. 
+ 62    elif n.resource_state == 'exists': 
+ 63      # Code to handle the exists state. 
+ 64    elif n.resource_state == 'not_exists': 
+ 65      # Code to handle the not exists state. 
+ 66   
+ 67   
+ 68  Example of unsubscribing. 
+ 69   
+ 70    service.channels().stop(channel.body()) 
+ 71  """ 
+ 72  from __future__ import absolute_import 
  73   
- 74  # The unix time epoch starts at midnight 1970. 
- 75  EPOCH = datetime.datetime.utcfromtimestamp(0) 
+ 74  import datetime 
+ 75  import uuid 
  76   
- 77  # Map the names of the parameters in the JSON channel description to 
- 78  # the parameter names we use in the Channel class. 
- 79  CHANNEL_PARAMS = { 
- 80      'address': 'address', 
- 81      'id': 'id', 
- 82      'expiration': 'expiration', 
- 83      'params': 'params', 
- 84      'resourceId': 'resource_id', 
- 85      'resourceUri': 'resource_uri', 
- 86      'type': 'type', 
- 87      'token': 'token', 
- 88      } 
- 89   
- 90  X_GOOG_CHANNEL_ID     = 'X-GOOG-CHANNEL-ID' 
- 91  X_GOOG_MESSAGE_NUMBER = 'X-GOOG-MESSAGE-NUMBER' 
- 92  X_GOOG_RESOURCE_STATE = 'X-GOOG-RESOURCE-STATE' 
- 93  X_GOOG_RESOURCE_URI   = 'X-GOOG-RESOURCE-URI' 
- 94  X_GOOG_RESOURCE_ID    = 'X-GOOG-RESOURCE-ID' 
- 95   
- 96   
- 97 -def _upper_header_keys(headers): 
-
 98    new_headers = {} 
- 99    for k, v in six.iteritems(headers): 
-100      new_headers[k.upper()] = v 
-101    return new_headers 
-
102   
-103   
-104 -class Notification(object): 
-
105    """A Notification from a Channel. 
-106   
-107    Notifications are not usually constructed directly, but are returned 
-108    from functions like notification_from_headers(). 
-109   
-110    Attributes: 
-111      message_number: int, The unique id number of this notification. 
-112      state: str, The state of the resource being monitored. 
-113      uri: str, The address of the resource being monitored. 
-114      resource_id: str, The unique identifier of the version of the resource at 
-115        this event. 
-116    """ 
-117    @util.positional(5) 
-118 -  def __init__(self, message_number, state, resource_uri, resource_id): 
-
119      """Notification constructor. 
-120   
-121      Args: 
-122        message_number: int, The unique id number of this notification. 
-123        state: str, The state of the resource being monitored. Can be one 
-124          of "exists", "not_exists", or "sync". 
-125        resource_uri: str, The address of the resource being monitored. 
-126        resource_id: str, The identifier of the watched resource. 
-127      """ 
-128      self.message_number = message_number 
-129      self.state = state 
-130      self.resource_uri = resource_uri 
-131      self.resource_id = resource_id 
-
132   
-133   
-134 -class Channel(object): 
-
135    """A Channel for notifications. 
-136   
-137    Usually not constructed directly, instead it is returned from helper 
-138    functions like new_webhook_channel(). 
-139   
-140    Attributes: 
-141      type: str, The type of delivery mechanism used by this channel. For 
-142        example, 'web_hook'. 
-143      id: str, A UUID for the channel. 
-144      token: str, An arbitrary string associated with the channel that 
-145        is delivered to the target address with each event delivered 
-146        over this channel. 
-147      address: str, The address of the receiving entity where events are 
-148        delivered. Specific to the channel type. 
-149      expiration: int, The time, in milliseconds from the epoch, when this 
-150        channel will expire. 
-151      params: dict, A dictionary of string to string, with additional parameters 
-152        controlling delivery channel behavior. 
-153      resource_id: str, An opaque id that identifies the resource that is 
-154        being watched. Stable across different API versions. 
-155      resource_uri: str, The canonicalized ID of the watched resource. 
-156    """ 
-157   
-158    @util.positional(5) 
-159 -  def __init__(self, type, id, token, address, expiration=None, 
-160                 params=None, resource_id="", resource_uri=""): 
-
161      """Create a new Channel. 
-162   
-163      In user code, this Channel constructor will not typically be called 
-164      manually since there are functions for creating channels for each specific 
-165      type with a more customized set of arguments to pass. 
-166   
-167      Args: 
-168        type: str, The type of delivery mechanism used by this channel. For 
-169          example, 'web_hook'. 
-170        id: str, A UUID for the channel. 
-171        token: str, An arbitrary string associated with the channel that 
-172          is delivered to the target address with each event delivered 
-173          over this channel. 
-174        address: str,  The address of the receiving entity where events are 
-175          delivered. Specific to the channel type. 
-176        expiration: int, The time, in milliseconds from the epoch, when this 
-177          channel will expire. 
-178        params: dict, A dictionary of string to string, with additional parameters 
-179          controlling delivery channel behavior. 
-180        resource_id: str, An opaque id that identifies the resource that is 
-181          being watched. Stable across different API versions. 
-182        resource_uri: str, The canonicalized ID of the watched resource. 
-183      """ 
-184      self.type = type 
-185      self.id = id 
-186      self.token = token 
-187      self.address = address 
-188      self.expiration = expiration 
-189      self.params = params 
-190      self.resource_id = resource_id 
-191      self.resource_uri = resource_uri 
-
192   
-193 -  def body(self): 
-
194      """Build a body from the Channel. 
-195   
-196      Constructs a dictionary that's appropriate for passing into watch() 
-197      methods as the value of body argument. 
-198   
-199      Returns: 
-200        A dictionary representation of the channel. 
-201      """ 
-202      result = { 
-203          'id': self.id, 
-204          'token': self.token, 
-205          'type': self.type, 
-206          'address': self.address 
-207          } 
-208      if self.params: 
-209        result['params'] = self.params 
-210      if self.resource_id: 
-211        result['resourceId'] = self.resource_id 
-212      if self.resource_uri: 
-213        result['resourceUri'] = self.resource_uri 
-214      if self.expiration: 
-215        result['expiration'] = self.expiration 
-216   
-217      return result 
-
218   
-219 -  def update(self, resp): 
-
220      """Update a channel with information from the response of watch(). 
-221   
-222      When a request is sent to watch() a resource, the response returned 
-223      from the watch() request is a dictionary with updated channel information, 
-224      such as the resource_id, which is needed when stopping a subscription. 
-225   
-226      Args: 
-227        resp: dict, The response from a watch() method. 
-228      """ 
-229      for json_name, param_name in six.iteritems(CHANNEL_PARAMS): 
-230        value = resp. 77  from googleapiclient import errors 
+ 78  from googleapiclient import _helpers as util 
+ 79  import six 
+ 80   
+ 81   
+ 82  # The unix time epoch starts at midnight 1970. 
+ 83  EPOCH = datetime.datetime.utcfromtimestamp(0) 
+ 84   
+ 85  # Map the names of the parameters in the JSON channel description to 
+ 86  # the parameter names we use in the Channel class. 
+ 87  CHANNEL_PARAMS = { 
+ 88      'address': 'address', 
+ 89      'id': 'id', 
+ 90      'expiration': 'expiration', 
+ 91      'params': 'params', 
+ 92      'resourceId': 'resource_id', 
+ 93      'resourceUri': 'resource_uri', 
+ 94      'type': 'type', 
+ 95      'token': 'token', 
+ 96      } 
+ 97   
+ 98  X_GOOG_CHANNEL_ID     = 'X-GOOG-CHANNEL-ID' 
+ 99  X_GOOG_MESSAGE_NUMBER = 'X-GOOG-MESSAGE-NUMBER' 
+100  X_GOOG_RESOURCE_STATE = 'X-GOOG-RESOURCE-STATE' 
+101  X_GOOG_RESOURCE_URI   = 'X-GOOG-RESOURCE-URI' 
+102  X_GOOG_RESOURCE_ID    = 'X-GOOG-RESOURCE-ID' 
+103   
+104   
+105 -def _upper_header_keys(headers): 
+
106    new_headers = {} 
+107    for k, v in six.iteritems(headers): 
+108      new_headers[k.upper()] = v 
+109    return new_headers 
+
110   
+111   
+112 -class Notification(object): 
+
113    """A Notification from a Channel. 
+114   
+115    Notifications are not usually constructed directly, but are returned 
+116    from functions like notification_from_headers(). 
+117   
+118    Attributes: 
+119      message_number: int, The unique id number of this notification. 
+120      state: str, The state of the resource being monitored. 
+121      uri: str, The address of the resource being monitored. 
+122      resource_id: str, The unique identifier of the version of the resource at 
+123        this event. 
+124    """ 
+125    @util.positional(5) 
+126 -  def __init__(self, message_number, state, resource_uri, resource_id): 
+
127      """Notification constructor. 
+128   
+129      Args: 
+130        message_number: int, The unique id number of this notification. 
+131        state: str, The state of the resource being monitored. Can be one 
+132          of "exists", "not_exists", or "sync". 
+133        resource_uri: str, The address of the resource being monitored. 
+134        resource_id: str, The identifier of the watched resource. 
+135      """ 
+136      self.message_number = message_number 
+137      self.state = state 
+138      self.resource_uri = resource_uri 
+139      self.resource_id = resource_id 
+
140   
+141   
+142 -class Channel(object): 
+
143    """A Channel for notifications. 
+144   
+145    Usually not constructed directly, instead it is returned from helper 
+146    functions like new_webhook_channel(). 
+147   
+148    Attributes: 
+149      type: str, The type of delivery mechanism used by this channel. For 
+150        example, 'web_hook'. 
+151      id: str, A UUID for the channel. 
+152      token: str, An arbitrary string associated with the channel that 
+153        is delivered to the target address with each event delivered 
+154        over this channel. 
+155      address: str, The address of the receiving entity where events are 
+156        delivered. Specific to the channel type. 
+157      expiration: int, The time, in milliseconds from the epoch, when this 
+158        channel will expire. 
+159      params: dict, A dictionary of string to string, with additional parameters 
+160        controlling delivery channel behavior. 
+161      resource_id: str, An opaque id that identifies the resource that is 
+162        being watched. Stable across different API versions. 
+163      resource_uri: str, The canonicalized ID of the watched resource. 
+164    """ 
+165   
+166    @util.positional(5) 
+167 -  def __init__(self, type, id, token, address, expiration=None, 
+168                 params=None, resource_id="", resource_uri=""): 
+
169      """Create a new Channel. 
+170   
+171      In user code, this Channel constructor will not typically be called 
+172      manually since there are functions for creating channels for each specific 
+173      type with a more customized set of arguments to pass. 
+174   
+175      Args: 
+176        type: str, The type of delivery mechanism used by this channel. For 
+177          example, 'web_hook'. 
+178        id: str, A UUID for the channel. 
+179        token: str, An arbitrary string associated with the channel that 
+180          is delivered to the target address with each event delivered 
+181          over this channel. 
+182        address: str,  The address of the receiving entity where events are 
+183          delivered. Specific to the channel type. 
+184        expiration: int, The time, in milliseconds from the epoch, when this 
+185          channel will expire. 
+186        params: dict, A dictionary of string to string, with additional parameters 
+187          controlling delivery channel behavior. 
+188        resource_id: str, An opaque id that identifies the resource that is 
+189          being watched. Stable across different API versions. 
+190        resource_uri: str, The canonicalized ID of the watched resource. 
+191      """ 
+192      self.type = type 
+193      self.id = id 
+194      self.token = token 
+195      self.address = address 
+196      self.expiration = expiration 
+197      self.params = params 
+198      self.resource_id = resource_id 
+199      self.resource_uri = resource_uri 
+
200   
+201 -  def body(self): 
+
202      """Build a body from the Channel. 
+203   
+204      Constructs a dictionary that's appropriate for passing into watch() 
+205      methods as the value of body argument. 
+206   
+207      Returns: 
+208        A dictionary representation of the channel. 
+209      """ 
+210      result = { 
+211          'id': self.id, 
+212          'token': self.token, 
+213          'type': self.type, 
+214          'address': self.address 
+215          } 
+216      if self.params: 
+217        result['params'] = self.params 
+218      if self.resource_id: 
+219        result['resourceId'] = self.resource_id 
+220      if self.resource_uri: 
+221        result['resourceUri'] = self.resource_uri 
+222      if self.expiration: 
+223        result['expiration'] = self.expiration 
+224   
+225      return result 
+
226   
+227 -  def update(self, resp): 
+
228      """Update a channel with information from the response of watch(). 
+229   
+230      When a request is sent to watch() a resource, the response returned 
+231      from the watch() request is a dictionary with updated channel information, 
+232      such as the resource_id, which is needed when stopping a subscription. 
+233   
+234      Args: 
+235        resp: dict, The response from a watch() method. 
+236      """ 
+237      for json_name, param_name in six.iteritems(CHANNEL_PARAMS): 
+238        value = resp.get(json_name) 
-231        if value is not None: 
-232          setattr(self, param_name, value) 
-
233   
-234   
-235 -def notification_from_headers(channel, headers): 
-
236    """Parse a notification from the webhook request headers, validate 
-237      the notification, and return a Notification object. 
-238   
-239    Args: 
-240      channel: Channel, The channel that the notification is associated with. 
-241      headers: dict, A dictionary like object that contains the request headers 
-242        from the webhook HTTP request. 
-243   
-244    Returns: 
-245      A Notification object. 
+googleapiclient.schema.Schemas.get" class="py-name" href="#" onclick="return doclink('link-14', 'get', 'link-14');">get(json_name) 
+239        if value is not None: 
+240          setattr(self, param_name, value) 
+
241   
+242   
+243 -def notification_from_headers(channel, headers): 
+
244    """Parse a notification from the webhook request headers, validate 
+245      the notification, and return a Notification object. 
 246   
-247    Raises: 
-248      errors.InvalidNotificationError if the notification is invalid. 
-249      ValueError if the X-GOOG-MESSAGE-NUMBER can't be converted to an int. 
-250    """ 
-251    headers = _upper_header_keys(headers) 
-252    channel_id = headers[X_GOOG_CHANNEL_ID] 
-253    if channel.id != channel_id: 
-254      raise errors.InvalidNotificationError( 
-255          'Channel id mismatch: %s != %s' % (channel.id, channel_id)) 
-256    else: 
-257      message_number = int(headers[X_GOOG_MESSAGE_NUMBER]) 
-258      state = headers[X_GOOG_RESOURCE_STATE] 
-259      resource_uri = headers[X_GOOG_RESOURCE_URI] 
-260      resource_id = headers[X_GOOG_RESOURCE_ID] 
-261      return Notification(message_number, state, resource_uri, resource_id) 
-
262   
-263   
-264  @util.positional(2) 
-265 -def new_webhook_channel(url, token=None, expiration=None, params=None): 
-
266      """Create a new webhook Channel. 
-267   
-268      Args: 
-269        url: str, URL to post notifications to. 
-270        token: str, An arbitrary string associated with the channel that 
-271          is delivered to the target address with each notification delivered 
-272          over this channel. 
-273        expiration: datetime.datetime, A time in the future when the channel 
-274          should expire. Can also be None if the subscription should use the 
-275          default expiration. Note that different services may have different 
-276          limits on how long a subscription lasts. Check the response from the 
-277          watch() method to see the value the service has set for an expiration 
-278          time. 
-279        params: dict, Extra parameters to pass on channel creation. Currently 
-280          not used for webhook channels. 
-281      """ 
-282      expiration_ms = 0 
-283      if expiration: 
-284        delta = expiration - EPOCH 
-285        expiration_ms = delta.microseconds/1000 + ( 
-286            delta.seconds + delta.days*24*3600)*1000 
-287        if expiration_ms < 0: 
-288          expiration_ms = 0 
-289   
-290      return Channel('web_hook', str(uuid.uuid4()), 
-291                     token, url, expiration=expiration_ms, 
-292                     params=params) 
-
293   
+
+
diff --git a/docs/epy/toc-googleapiclient.http-module.html b/docs/epy/toc-googleapiclient.http-module.html
index a6ab0e09810..1221469f64e 100644
--- a/docs/epy/toc-googleapiclient.http-module.html
+++ b/docs/epy/toc-googleapiclient.http-module.html
@@ -45,6 +45,9 @@ Functions
      >DEFAULT_HTTP_TIMEOUT_SEC
    LOGGER
    MAX_URI_LENGTH
  
+    _LEGACY_BATCH_URI
  
+  
     _TOO_MANY_REQUESTS
  
   
diff --git a/docs/epy/toc.html b/docs/epy/toc.html
index 019e619e508..ac8c6d61560 100644
--- a/docs/epy/toc.html
+++ b/docs/epy/toc.html
@@ -19,6 +19,9 @@ Modules
      onclick="setFrame('toc-googleapiclient-module.html','googleapiclient-module.html');"     >googleapiclient
  
     googleapiclient._auth
  
+  
+    googleapiclient._helpers
  
     googleapiclient.channel
    googleapiclient.discovery

Class Hierarchy

Package googleapiclient

Package googleapiclient

Class NullHandler

emit(

Module _auth

authorized_http

Source Code for Module googleapiclient._auth

Module _helpers

positional(max_positional_args) +

parse_unique_urlencoded(content) +

update_query_params(uri, + params) +

_add_query_parameter(url, + name, + value) +

POSITIONAL_SET

_MISSING_FILE_MESSAGE

Source Code for Module googleapiclient._helpers

CHANNEL_PARAMS

Source Code for Module googleapiclient.channel

Functions

Modules