Update oauth2client to v2.0.1 and googleapiclient to v1.5.0.

client/third_party/oauth2client/contrib/multistore_file.py

 # Copyright 2014 Google Inc. All rights reserved.
 #
 # 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,
@@ skipping 35 matching lines @@
 
 import errno
 import json
 import logging
 import os
 import threading
 
 from oauth2client.client import Credentials
 from oauth2client.client import Storage as BaseStorage
 from oauth2client import util
-from oauth2client.locked_file import LockedFile
+from oauth2client.contrib.locked_file import LockedFile
 
 
 __author__ = 'jbeda@google.com (Joe Beda)'
 
 logger = logging.getLogger(__name__)
 
 # A dict from 'filename'->_MultiStore instances
 _multistores = {}
 _multistores_lock = threading.Lock()
 
 
 class Error(Exception):
     """Base error for this module."""
 
 
 class NewerCredentialStoreError(Error):
     """The credential store is a newer version than supported."""
 
 
+def _dict_to_tuple_key(dictionary):
+    """Converts a dictionary to a tuple that can be used as an immutable key.
+
+    The resulting key is always sorted so that logically equivalent
+    dictionaries always produce an identical tuple for a key.
+
+    Args:
+        dictionary: the dictionary to use as the key.
+
+    Returns:
+        A tuple representing the dictionary in it's naturally sorted ordering.
+    """
+    return tuple(sorted(dictionary.items()))
+
+
 @util.positional(4)
 def get_credential_storage(filename, client_id, user_agent, scope,
                            warn_on_readonly=True):
     """Get a Storage instance for a credential.
 
     Args:
         filename: The JSON file storing a set of credentials
         client_id: The client_id for the credential
         user_agent: The user agent for the credential
         scope: string or iterable of strings, Scope(s) being requested
@@ skipping 46 matching lines @@
         key_dict: A dictionary to use as the key for storing this credential.
                   There is no ordering of the keys in the dictionary. Logically
                   equivalent dictionaries will produce equivalent storage keys.
         warn_on_readonly: if True, log a warning if the store is readonly
 
     Returns:
         An object derived from client.Storage for getting/setting the
         credential.
     """
     multistore = _get_multistore(filename, warn_on_readonly=warn_on_readonly)
-    key = util.dict_to_tuple_key(key_dict)
+    key = _dict_to_tuple_key(key_dict)
     return multistore._get_storage(key)
 
 
 @util.positional(1)
 def get_all_credential_keys(filename, warn_on_readonly=True):
     """Gets all the registered credential keys in the given Multistore.
 
     Args:
         filename: The JSON file storing a set of credentials
         warn_on_readonly: if True, log a warning if the store is readonly
@@ skipping 133 matching lines @@
         except IOError as e:
             if e.errno == errno.ENOSYS:
                 logger.warn('File system does not support locking the '
                             'credentials file.')
             elif e.errno == errno.ENOLCK:
                 logger.warn('File system is out of resources for writing the '
                             'credentials file (is your disk full?).')
             elif e.errno == errno.EDEADLK:
                 logger.warn('Lock contention on multistore file, opening '
                             'in read-only mode.')
+            elif e.errno == errno.EACCES:
+                logger.warn('Cannot access credentials file.')
             else:
                 raise
         if not self._file.is_locked():
             self._read_only = True
             if self._warn_on_readonly:
                 logger.warn('The credentials file (%s) is not writable. '
                             'Opening in read-only mode. Any refreshed '
                             'credentials will only be '
                             'valid for this run.', self._file.filename())
         if os.path.getsize(self._file.filename()) == 0:
@@ skipping 89 matching lines @@
         """Load a credential from our JSON serialization.
 
         Args:
             cred_entry: A dict entry from the data member of our format
 
         Returns:
             (key, cred) where the key is the key tuple and the cred is the
             OAuth2Credential object.
         """
         raw_key = cred_entry['key']
-        key = util.dict_to_tuple_key(raw_key)
+        key = _dict_to_tuple_key(raw_key)
         credential = None
         credential = Credentials.new_from_json(
             json.dumps(cred_entry['credential']))
         return (key, credential)
 
     def _write(self):
         """Write the cached data back out.
 
         The multistore must be locked.
         """
@@ skipping 59 matching lines @@
 
         This Storage is a 'view' into the multistore.
 
         Args:
             key: The key used to retrieve the credential
 
         Returns:
             A Storage object that can be used to get/set this cred
         """
         return self._Storage(self, key)