Merge branch 'master' into krypton

addon.xml

@@ -5,10 +5,10 @@
 	<!-- jarvis -->
     <import addon="xbmc.python" version="2.25.0"/>
     <import addon="script.module.httplib2" version="0.8.0" />
-    <import addon="script.module.oauth2client" version="1.4.11" />
+    <import addon="script.module.oauth2client" version="4.1.2" />
     <import addon="script.module.uritemplate" version="0.6" />
     <import addon="script.module.yaml" version="3.11"/>
-    <import addon="script.module.googleapi" version="1.4.2" />
+    <import addon="script.module.googleapi" version="1.6.4" />
 	<import addon="script.module.requests" version="2.9.1" />
   </requires>
   <extension point="xbmc.python.script" library="default.py"> 

changelog.txt

@@ -2,6 +2,8 @@ Version 1.1.1
 
 fixed error on authorizers (missing secret/key)
 added ability to "catchup" on missed scheduled backup
+updated google oauth and client versions
+merged in dropbox v2 code
 
 Version 1.1.0
 

resources/language/resource.language.en_gb/strings.po

@@ -394,8 +394,8 @@ msgid "Click OK to enter code"
 msgstr "Click OK to enter code"
 
 msgctxt "#30103"
-msgid "Google Drive Validation Code"
-msgstr "Google Drive Validation Code"
+msgid "Validation Code"
+msgstr "Validation Code"
 
 msgctxt "#30104"
 msgid "Authorize Now"

resources/lib/authorizers.py

@@ -3,9 +3,7 @@ import xbmcgui
 import xbmcvfs
 import resources.lib.tinyurl as tinyurl
 import resources.lib.utils as utils
-from resources.lib.dropbox import client, rest, session
-from resources.lib.pydrive.auth import GoogleAuth
-from resources.lib.pydrive.drive import GoogleDrive
+import dropbox
 
 class DropboxAuthorizer:
     APP_KEY = ""
@@ -27,9 +25,9 @@ class DropboxAuthorizer:
         return result    
 
     def isAuthorized(self):
-        user_token_key,user_token_secret = self._getToken()
+        user_token = self._getToken()
 
-        return user_token_key != '' and user_token_secret != ''        
+        return user_token != ''        
 
     def authorize(self):
         result = True
@@ -41,56 +39,64 @@ class DropboxAuthorizer:
             #delete the token to start over
             self._deleteToken()
 
-        sess = session.DropboxSession(self.APP_KEY,self.APP_SECRET,"app_folder")
+        #copied flow from http://dropbox-sdk-python.readthedocs.io/en/latest/moduledoc.html#dropbox.oauth.DropboxOAuth2FlowNoRedirect
+        flow = dropbox.oauth.DropboxOAuth2FlowNoRedirect(self.APP_KEY,self.APP_SECRET)
 
-        token = sess.obtain_request_token()
-        url = sess.build_authorize_url(token)
+        url = flow.start()
 
         #print url in log
         utils.log("Authorize URL: " + url)
         xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30056),utils.getString(30057),tinyurl.shorten(url))
-            
-        #if user authorized this will work
-        user_token = sess.obtain_access_token(token)
-        self._setToken(user_token.key,user_token.secret)
 
+        #get the auth code
+        code = xbmcgui.Dialog().input(utils.getString(30027) + ' ' + utils.getString(30103))
+        
+        #if user authorized this will work
+
+        try:
+            user_token = flow.finish(code)
+            self._setToken(user_token.access_token)
+        except Exception,e:
+            utils.log("Error: %s" % (e,))
+            result = False
+            
         return result;
 
     #return the DropboxClient, or None if can't be created
     def getClient(self):
         result = None
-        sess = session.DropboxSession(self.APP_KEY,self.APP_SECRET,"app_folder")
-        user_token_key,user_token_secret = self._getToken()
 
-        if(user_token_key != '' and user_token_secret != ''):
+        user_token = self._getToken()
+
+        if(user_token != ''):
             #create the client
-            sess.set_token(user_token_key,user_token_secret)
-            result = client.DropboxClient(sess)
+            result = dropbox.Dropbox(user_token)
 
             try:
-                utils.log(str(result.account_info()))
+                result.users_get_current_account()
             except:
                 #this didn't work, delete the token file
                 self._deleteToken()
+                result = None
                 
         return result
 
-    def _setToken(self,key,secret):
+    def _setToken(self,token):
         #write the token files
         token_file = open(xbmc.translatePath(utils.data_dir() + "tokens.txt"),'w')
-        token_file.write("%s|%s" % (key,secret))
+        token_file.write(token)
         token_file.close()
 
     def _getToken(self):
-        #get tokens, if they exist
+        #get token, if it exists
         if(xbmcvfs.exists(xbmc.translatePath(utils.data_dir() + "tokens.txt"))):
             token_file = open(xbmc.translatePath(utils.data_dir() + "tokens.txt"))
-            key,secret = token_file.read().split('|')
+            token = token_file.read()
             token_file.close()
 
-            return [key,secret]
+            return token
         else:
-            return ["",""]
+            return ""
         
     def _deleteToken(self):
         if(xbmcvfs.exists(xbmc.translatePath(utils.data_dir() + "tokens.txt"))):
@@ -134,7 +140,7 @@ class GoogleDriveAuthorizer:
         utils.log("Google Drive Authorize URL: " + drive_url)
 
         xbmcgui.Dialog().ok(utils.getString(30010),utils.getString(30056),utils.getString(30102),tinyurl.shorten(drive_url))
-        code = xbmcgui.Dialog().input(utils.getString(30103))
+        code = xbmcgui.Dialog().input(utils.getString(30098) + ' ' + utils.getString(30103))
 
         gauth.Auth(code)
         gauth.SaveCredentialsFile(xbmc.validatePath(xbmc.translatePath(utils.data_dir() + 'google_drive.dat')))

resources/lib/dropbox/CHANGELOG.mdown

@@ -1,103 +0,0 @@
-Changes to the Python SDK
-=========================
-
-Changes in 2.2.0 (2014-09-16)
------------------------------
-- Support for Datastore sharing
-- `DropboxClient.get_file()`: Add support for `start`, `length` parameters.
-- Add support for the /longpoll_delta API
-- Add direct support for /chunked_upload and /commit_chunked_upload APIs
-- Fix error handling in ChunkedUploader
-- Make tests compatible with py.test
-- Various docstring updates (including OAuth 1->2 example)
-- Fix encoding issues in example/cli_client.py
-- Fix unicode handling for URL parameters
-
-Changes in 2.1.0 (2014-06-03)
------------------------------
-- The datastore API now includes size accessors to allow you to check the size of your data and avoid the syncing limits.
-- The datastore Date() constructor now truncates timestamps to the supported resolution, i.e. milliseconds.
-- The datastore `await*()` calls now use POST instead of GET.
-- Datastore IDs, table IDs, record IDs and field names may be 64 characters (increased from 32 characters).  Before taking advantage of the new size limits ensure your application is fully upgraded to SDKs with this support.
-- Option to `include_media_info` has been added to `DropboxClient.metadata()` and `DropboxClient.delta()`.
-
-Changes in 2.0.0 (2013-12-19)
------------------------------
-- Add the Datastore API.
-- Upgrade OAuth 1 tokens with `DropboxClient.create_oauth2_access_token` and `DropboxClient.disable_oauth2_access_token`.
-- `DropboxClient.thumbnail()`: Fix `size` identifiers.
-- `DropboxClient.delta()`: Add support for `path_prefix` parameter.
-- Connection reuse/pooling using urllib3.
-- Updated SSL settings.
-- Various documentation reformatting.
-
-Changes in 1.6 (2013-07-07)
-----------------
-- Added OAuth 2 support (use DropboxOAuth2Flow).  OAuth 1 still works.
-- Added a Flask-based example.
-- Fixed many minor bugs.
-
-Changes in 1.5.1 (2012-8-20)
------------------
-- Fixed packaging.
-- Got rid of debug prints.
-
-Changes in 1.5 (2012-8-15)
---------------------------
-- Support for uploading large files via /chunked_upload
-
-Changes in 1.4.1 (2012-5-16)
-----------------------------
-- Increase metadata() file list limit to 25,000 (used to be 10,000).
-- Removed debug prints from search() call.  Oops.
-- Cleanup to make more compatible with Python 3.
-
-Changes in 1.4 (2012-3-26)
---------------------------
-- Add support for the /delta API.
-- Add support for the "copy ref" API.
-
-Changes in 1.3 (2012-1-11)
---------------------------
-- Adds a method to the SDK that returns the file metadata when downloading a
-  file or its thumbnail.
-- Validate server's SSL certificate against CAs in included certificate file.
-
-Changes in 1.2 (2011-10-17)
----------------------------
-- Fixes for bugs found during beta period
-- Improved README to include steps to remove the v0 SDK if upgrading
-
-Changes in 1.1 (2011-8-16)
---------------------------
-- Fixed version number
-- Updated CHANGELOG to be more detailed
-
-Changes in 1.0 (2011-7-11)
---------------------------
-- Backwards compatibility broken
-   - Completely removed 'callback' and 'status\_in\_response' parameters
-   - Change 'sandbox' references to 'app\_folder'
-   - Refactored auth.py and renamed it session.py
-- Updated SDK to Dropbox API Version 1, supporting all calls
-   - Added 'rev' parameter to metadata and get\_file
-   - Added 'parent\_rev' parameter to put\_file
-   - Added search, share, media, revisions, and restore
-   - put\_file uses /files\_put instead of multipart POST and now takes a full path
-   - Removed methods for calls that were removed from v1 of the REST API
-- Removed 'root' input parameter for all calls
-- Changed return format for calls
-   - On error (non-200 response), an exception is raised
-   - On success, the JSON is parsed and a Python dict or list is returned
-- Updated examples
-   - Renamed 'bin' directory to 'example'
-   - Heavily tweaked the CLI example
-   - Added a web app example
-- Removed reliance on config files
-- Assorted bugfixes and improvements
-   - Buffers large file uploads better in put\_file
-   - Improved path normalization
-- All calls are now made over SSL
-- Fully documented code for Pydoc generation
-- Added a CHANGELOG
-- Changed the distribution name from 'dropbox-client' to 'dropbox-python-sdk'

resources/lib/dropbox/__init__.py

@@ -1,3 +1,4 @@
 from __future__ import absolute_import
 
-from . import client, rest, session
+from .dropbox import __version__, Dropbox, DropboxTeam, create_session  # noqa: F401
+from .oauth import DropboxOAuth2Flow, DropboxOAuth2FlowNoRedirect  # noqa: F401

resources/lib/dropbox/async.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+class LaunchResultBase(bb.Union):
+    """
+    Result returned by methods that launch an asynchronous job. A method who may
+    either launch an asynchronous job, or complete the request synchronously,
+    can use this union by extending it, and adding a 'complete' field with the
+    type of the synchronous response. See :class:`LaunchEmptyResult` for an
+    example.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar str async_job_id: This response indicates that the processing is
+        asynchronous. The string is an id that can be used to obtain the status
+        of the asynchronous job.
+    """
+
+    _catch_all = None
+
+    @classmethod
+    def async_job_id(cls, val):
+        """
+        Create an instance of this class set to the ``async_job_id`` tag with
+        value ``val``.
+
+        :param str val:
+        :rtype: LaunchResultBase
+        """
+        return cls('async_job_id', val)
+
+    def is_async_job_id(self):
+        """
+        Check if the union tag is ``async_job_id``.
+
+        :rtype: bool
+        """
+        return self._tag == 'async_job_id'
+
+    def get_async_job_id(self):
+        """
+        This response indicates that the processing is asynchronous. The string
+        is an id that can be used to obtain the status of the asynchronous job.
+
+        Only call this if :meth:`is_async_job_id` is true.
+
+        :rtype: str
+        """
+        if not self.is_async_job_id():
+            raise AttributeError("tag 'async_job_id' not set")
+        return self._value
+
+    def __repr__(self):
+        return 'LaunchResultBase(%r, %r)' % (self._tag, self._value)
+
+LaunchResultBase_validator = bv.Union(LaunchResultBase)
+
+class LaunchEmptyResult(LaunchResultBase):
+    """
+    Result returned by methods that may either launch an asynchronous job or
+    complete synchronously. Upon synchronous completion of the job, no
+    additional information is returned.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar complete: The job finished synchronously and successfully.
+    """
+
+    # Attribute is overwritten below the class definition
+    complete = None
+
+    def is_complete(self):
+        """
+        Check if the union tag is ``complete``.
+
+        :rtype: bool
+        """
+        return self._tag == 'complete'
+
+    def __repr__(self):
+        return 'LaunchEmptyResult(%r, %r)' % (self._tag, self._value)
+
+LaunchEmptyResult_validator = bv.Union(LaunchEmptyResult)
+
+class PollArg(object):
+    """
+    Arguments for methods that poll the status of an asynchronous job.
+
+    :ivar async_job_id: Id of the asynchronous job. This is the value of a
+        response returned from the method that launched the job.
+    """
+
+    __slots__ = [
+        '_async_job_id_value',
+        '_async_job_id_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 async_job_id=None):
+        self._async_job_id_value = None
+        self._async_job_id_present = False
+        if async_job_id is not None:
+            self.async_job_id = async_job_id
+
+    @property
+    def async_job_id(self):
+        """
+        Id of the asynchronous job. This is the value of a response returned
+        from the method that launched the job.
+
+        :rtype: str
+        """
+        if self._async_job_id_present:
+            return self._async_job_id_value
+        else:
+            raise AttributeError("missing required field 'async_job_id'")
+
+    @async_job_id.setter
+    def async_job_id(self, val):
+        val = self._async_job_id_validator.validate(val)
+        self._async_job_id_value = val
+        self._async_job_id_present = True
+
+    @async_job_id.deleter
+    def async_job_id(self):
+        self._async_job_id_value = None
+        self._async_job_id_present = False
+
+    def __repr__(self):
+        return 'PollArg(async_job_id={!r})'.format(
+            self._async_job_id_value,
+        )
+
+PollArg_validator = bv.Struct(PollArg)
+
+class PollResultBase(bb.Union):
+    """
+    Result returned by methods that poll for the status of an asynchronous job.
+    Unions that extend this union should add a 'complete' field with a type of
+    the information returned upon job completion. See :class:`PollEmptyResult`
+    for an example.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar in_progress: The asynchronous job is still in progress.
+    """
+
+    _catch_all = None
+    # Attribute is overwritten below the class definition
+    in_progress = None
+
+    def is_in_progress(self):
+        """
+        Check if the union tag is ``in_progress``.
+
+        :rtype: bool
+        """
+        return self._tag == 'in_progress'
+
+    def __repr__(self):
+        return 'PollResultBase(%r, %r)' % (self._tag, self._value)
+
+PollResultBase_validator = bv.Union(PollResultBase)
+
+class PollEmptyResult(PollResultBase):
+    """
+    Result returned by methods that poll for the status of an asynchronous job.
+    Upon completion of the job, no additional information is returned.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar complete: The asynchronous job has completed successfully.
+    """
+
+    # Attribute is overwritten below the class definition
+    complete = None
+
+    def is_complete(self):
+        """
+        Check if the union tag is ``complete``.
+
+        :rtype: bool
+        """
+        return self._tag == 'complete'
+
+    def __repr__(self):
+        return 'PollEmptyResult(%r, %r)' % (self._tag, self._value)
+
+PollEmptyResult_validator = bv.Union(PollEmptyResult)
+
+class PollError(bb.Union):
+    """
+    Error returned by methods for polling the status of asynchronous job.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar invalid_async_job_id: The job ID is invalid.
+    :ivar internal_error: Something went wrong with the job on Dropbox's end.
+        You'll need to verify that the action you were taking succeeded, and if
+        not, try again. This should happen very rarely.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    invalid_async_job_id = None
+    # Attribute is overwritten below the class definition
+    internal_error = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_invalid_async_job_id(self):
+        """
+        Check if the union tag is ``invalid_async_job_id``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_async_job_id'
+
+    def is_internal_error(self):
+        """
+        Check if the union tag is ``internal_error``.
+
+        :rtype: bool
+        """
+        return self._tag == 'internal_error'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'PollError(%r, %r)' % (self._tag, self._value)
+
+PollError_validator = bv.Union(PollError)
+
+AsyncJobId_validator = bv.String(min_length=1)
+LaunchResultBase._async_job_id_validator = AsyncJobId_validator
+LaunchResultBase._tagmap = {
+    'async_job_id': LaunchResultBase._async_job_id_validator,
+}
+
+LaunchEmptyResult._complete_validator = bv.Void()
+LaunchEmptyResult._tagmap = {
+    'complete': LaunchEmptyResult._complete_validator,
+}
+LaunchEmptyResult._tagmap.update(LaunchResultBase._tagmap)
+
+LaunchEmptyResult.complete = LaunchEmptyResult('complete')
+
+PollArg._async_job_id_validator = AsyncJobId_validator
+PollArg._all_field_names_ = set(['async_job_id'])
+PollArg._all_fields_ = [('async_job_id', PollArg._async_job_id_validator)]
+
+PollResultBase._in_progress_validator = bv.Void()
+PollResultBase._tagmap = {
+    'in_progress': PollResultBase._in_progress_validator,
+}
+
+PollResultBase.in_progress = PollResultBase('in_progress')
+
+PollEmptyResult._complete_validator = bv.Void()
+PollEmptyResult._tagmap = {
+    'complete': PollEmptyResult._complete_validator,
+}
+PollEmptyResult._tagmap.update(PollResultBase._tagmap)
+
+PollEmptyResult.complete = PollEmptyResult('complete')
+
+PollError._invalid_async_job_id_validator = bv.Void()
+PollError._internal_error_validator = bv.Void()
+PollError._other_validator = bv.Void()
+PollError._tagmap = {
+    'invalid_async_job_id': PollError._invalid_async_job_id_validator,
+    'internal_error': PollError._internal_error_validator,
+    'other': PollError._other_validator,
+}
+
+PollError.invalid_async_job_id = PollError('invalid_async_job_id')
+PollError.internal_error = PollError('internal_error')
+PollError.other = PollError('other')
+
+ROUTES = {
+}
+

resources/lib/dropbox/auth.py

@@ -0,0 +1,723 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+class AccessError(bb.Union):
+    """
+    Error occurred because the account doesn't have permission to access the
+    resource.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar InvalidAccountTypeError invalid_account_type: Current account type
+        cannot access the resource.
+    :ivar PaperAccessError paper_access_denied: Current account cannot access
+        Paper.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    other = None
+
+    @classmethod
+    def invalid_account_type(cls, val):
+        """
+        Create an instance of this class set to the ``invalid_account_type`` tag
+        with value ``val``.
+
+        :param InvalidAccountTypeError val:
+        :rtype: AccessError
+        """
+        return cls('invalid_account_type', val)
+
+    @classmethod
+    def paper_access_denied(cls, val):
+        """
+        Create an instance of this class set to the ``paper_access_denied`` tag
+        with value ``val``.
+
+        :param PaperAccessError val:
+        :rtype: AccessError
+        """
+        return cls('paper_access_denied', val)
+
+    def is_invalid_account_type(self):
+        """
+        Check if the union tag is ``invalid_account_type``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_account_type'
+
+    def is_paper_access_denied(self):
+        """
+        Check if the union tag is ``paper_access_denied``.
+
+        :rtype: bool
+        """
+        return self._tag == 'paper_access_denied'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def get_invalid_account_type(self):
+        """
+        Current account type cannot access the resource.
+
+        Only call this if :meth:`is_invalid_account_type` is true.
+
+        :rtype: InvalidAccountTypeError
+        """
+        if not self.is_invalid_account_type():
+            raise AttributeError("tag 'invalid_account_type' not set")
+        return self._value
+
+    def get_paper_access_denied(self):
+        """
+        Current account cannot access Paper.
+
+        Only call this if :meth:`is_paper_access_denied` is true.
+
+        :rtype: PaperAccessError
+        """
+        if not self.is_paper_access_denied():
+            raise AttributeError("tag 'paper_access_denied' not set")
+        return self._value
+
+    def __repr__(self):
+        return 'AccessError(%r, %r)' % (self._tag, self._value)
+
+AccessError_validator = bv.Union(AccessError)
+
+class AuthError(bb.Union):
+    """
+    Errors occurred during authentication.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar invalid_access_token: The access token is invalid.
+    :ivar invalid_select_user: The user specified in 'Dropbox-API-Select-User'
+        is no longer on the team.
+    :ivar invalid_select_admin: The user specified in 'Dropbox-API-Select-Admin'
+        is not a Dropbox Business team admin.
+    :ivar user_suspended: The user has been suspended.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    invalid_access_token = None
+    # Attribute is overwritten below the class definition
+    invalid_select_user = None
+    # Attribute is overwritten below the class definition
+    invalid_select_admin = None
+    # Attribute is overwritten below the class definition
+    user_suspended = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_invalid_access_token(self):
+        """
+        Check if the union tag is ``invalid_access_token``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_access_token'
+
+    def is_invalid_select_user(self):
+        """
+        Check if the union tag is ``invalid_select_user``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_select_user'
+
+    def is_invalid_select_admin(self):
+        """
+        Check if the union tag is ``invalid_select_admin``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_select_admin'
+
+    def is_user_suspended(self):
+        """
+        Check if the union tag is ``user_suspended``.
+
+        :rtype: bool
+        """
+        return self._tag == 'user_suspended'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'AuthError(%r, %r)' % (self._tag, self._value)
+
+AuthError_validator = bv.Union(AuthError)
+
+class InvalidAccountTypeError(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar endpoint: Current account type doesn't have permission to access this
+        route endpoint.
+    :ivar feature: Current account type doesn't have permission to access this
+        feature.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    endpoint = None
+    # Attribute is overwritten below the class definition
+    feature = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_endpoint(self):
+        """
+        Check if the union tag is ``endpoint``.
+
+        :rtype: bool
+        """
+        return self._tag == 'endpoint'
+
+    def is_feature(self):
+        """
+        Check if the union tag is ``feature``.
+
+        :rtype: bool
+        """
+        return self._tag == 'feature'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'InvalidAccountTypeError(%r, %r)' % (self._tag, self._value)
+
+InvalidAccountTypeError_validator = bv.Union(InvalidAccountTypeError)
+
+class PaperAccessError(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar paper_disabled: Paper is disabled.
+    :ivar not_paper_user: The provided user has not used Paper yet.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    paper_disabled = None
+    # Attribute is overwritten below the class definition
+    not_paper_user = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_paper_disabled(self):
+        """
+        Check if the union tag is ``paper_disabled``.
+
+        :rtype: bool
+        """
+        return self._tag == 'paper_disabled'
+
+    def is_not_paper_user(self):
+        """
+        Check if the union tag is ``not_paper_user``.
+
+        :rtype: bool
+        """
+        return self._tag == 'not_paper_user'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'PaperAccessError(%r, %r)' % (self._tag, self._value)
+
+PaperAccessError_validator = bv.Union(PaperAccessError)
+
+class RateLimitError(object):
+    """
+    Error occurred because the app is being rate limited.
+
+    :ivar reason: The reason why the app is being rate limited.
+    :ivar retry_after: The number of seconds that the app should wait before
+        making another request.
+    """
+
+    __slots__ = [
+        '_reason_value',
+        '_reason_present',
+        '_retry_after_value',
+        '_retry_after_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 reason=None,
+                 retry_after=None):
+        self._reason_value = None
+        self._reason_present = False
+        self._retry_after_value = None
+        self._retry_after_present = False
+        if reason is not None:
+            self.reason = reason
+        if retry_after is not None:
+            self.retry_after = retry_after
+
+    @property
+    def reason(self):
+        """
+        The reason why the app is being rate limited.
+
+        :rtype: RateLimitReason
+        """
+        if self._reason_present:
+            return self._reason_value
+        else:
+            raise AttributeError("missing required field 'reason'")
+
+    @reason.setter
+    def reason(self, val):
+        self._reason_validator.validate_type_only(val)
+        self._reason_value = val
+        self._reason_present = True
+
+    @reason.deleter
+    def reason(self):
+        self._reason_value = None
+        self._reason_present = False
+
+    @property
+    def retry_after(self):
+        """
+        The number of seconds that the app should wait before making another
+        request.
+
+        :rtype: long
+        """
+        if self._retry_after_present:
+            return self._retry_after_value
+        else:
+            return 1
+
+    @retry_after.setter
+    def retry_after(self, val):
+        val = self._retry_after_validator.validate(val)
+        self._retry_after_value = val
+        self._retry_after_present = True
+
+    @retry_after.deleter
+    def retry_after(self):
+        self._retry_after_value = None
+        self._retry_after_present = False
+
+    def __repr__(self):
+        return 'RateLimitError(reason={!r}, retry_after={!r})'.format(
+            self._reason_value,
+            self._retry_after_value,
+        )
+
+RateLimitError_validator = bv.Struct(RateLimitError)
+
+class RateLimitReason(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar too_many_requests: You are making too many requests in the past few
+        minutes.
+    :ivar too_many_write_operations: There are currently too many write
+        operations happening in the user's Dropbox.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    too_many_requests = None
+    # Attribute is overwritten below the class definition
+    too_many_write_operations = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_too_many_requests(self):
+        """
+        Check if the union tag is ``too_many_requests``.
+
+        :rtype: bool
+        """
+        return self._tag == 'too_many_requests'
+
+    def is_too_many_write_operations(self):
+        """
+        Check if the union tag is ``too_many_write_operations``.
+
+        :rtype: bool
+        """
+        return self._tag == 'too_many_write_operations'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'RateLimitReason(%r, %r)' % (self._tag, self._value)
+
+RateLimitReason_validator = bv.Union(RateLimitReason)
+
+class TokenFromOAuth1Arg(object):
+    """
+    :ivar oauth1_token: The supplied OAuth 1.0 access token.
+    :ivar oauth1_token_secret: The token secret associated with the supplied
+        access token.
+    """
+
+    __slots__ = [
+        '_oauth1_token_value',
+        '_oauth1_token_present',
+        '_oauth1_token_secret_value',
+        '_oauth1_token_secret_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 oauth1_token=None,
+                 oauth1_token_secret=None):
+        self._oauth1_token_value = None
+        self._oauth1_token_present = False
+        self._oauth1_token_secret_value = None
+        self._oauth1_token_secret_present = False
+        if oauth1_token is not None:
+            self.oauth1_token = oauth1_token
+        if oauth1_token_secret is not None:
+            self.oauth1_token_secret = oauth1_token_secret
+
+    @property
+    def oauth1_token(self):
+        """
+        The supplied OAuth 1.0 access token.
+
+        :rtype: str
+        """
+        if self._oauth1_token_present:
+            return self._oauth1_token_value
+        else:
+            raise AttributeError("missing required field 'oauth1_token'")
+
+    @oauth1_token.setter
+    def oauth1_token(self, val):
+        val = self._oauth1_token_validator.validate(val)
+        self._oauth1_token_value = val
+        self._oauth1_token_present = True
+
+    @oauth1_token.deleter
+    def oauth1_token(self):
+        self._oauth1_token_value = None
+        self._oauth1_token_present = False
+
+    @property
+    def oauth1_token_secret(self):
+        """
+        The token secret associated with the supplied access token.
+
+        :rtype: str
+        """
+        if self._oauth1_token_secret_present:
+            return self._oauth1_token_secret_value
+        else:
+            raise AttributeError("missing required field 'oauth1_token_secret'")
+
+    @oauth1_token_secret.setter
+    def oauth1_token_secret(self, val):
+        val = self._oauth1_token_secret_validator.validate(val)
+        self._oauth1_token_secret_value = val
+        self._oauth1_token_secret_present = True
+
+    @oauth1_token_secret.deleter
+    def oauth1_token_secret(self):
+        self._oauth1_token_secret_value = None
+        self._oauth1_token_secret_present = False
+
+    def __repr__(self):
+        return 'TokenFromOAuth1Arg(oauth1_token={!r}, oauth1_token_secret={!r})'.format(
+            self._oauth1_token_value,
+            self._oauth1_token_secret_value,
+        )
+
+TokenFromOAuth1Arg_validator = bv.Struct(TokenFromOAuth1Arg)
+
+class TokenFromOAuth1Error(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar invalid_oauth1_token_info: Part or all of the OAuth 1.0 access token
+        info is invalid.
+    :ivar app_id_mismatch: The authorized app does not match the app associated
+        with the supplied access token.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    invalid_oauth1_token_info = None
+    # Attribute is overwritten below the class definition
+    app_id_mismatch = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_invalid_oauth1_token_info(self):
+        """
+        Check if the union tag is ``invalid_oauth1_token_info``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid_oauth1_token_info'
+
+    def is_app_id_mismatch(self):
+        """
+        Check if the union tag is ``app_id_mismatch``.
+
+        :rtype: bool
+        """
+        return self._tag == 'app_id_mismatch'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'TokenFromOAuth1Error(%r, %r)' % (self._tag, self._value)
+
+TokenFromOAuth1Error_validator = bv.Union(TokenFromOAuth1Error)
+
+class TokenFromOAuth1Result(object):
+    """
+    :ivar oauth2_token: The OAuth 2.0 token generated from the supplied OAuth
+        1.0 token.
+    """
+
+    __slots__ = [
+        '_oauth2_token_value',
+        '_oauth2_token_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 oauth2_token=None):
+        self._oauth2_token_value = None
+        self._oauth2_token_present = False
+        if oauth2_token is not None:
+            self.oauth2_token = oauth2_token
+
+    @property
+    def oauth2_token(self):
+        """
+        The OAuth 2.0 token generated from the supplied OAuth 1.0 token.
+
+        :rtype: str
+        """
+        if self._oauth2_token_present:
+            return self._oauth2_token_value
+        else:
+            raise AttributeError("missing required field 'oauth2_token'")
+
+    @oauth2_token.setter
+    def oauth2_token(self, val):
+        val = self._oauth2_token_validator.validate(val)
+        self._oauth2_token_value = val
+        self._oauth2_token_present = True
+
+    @oauth2_token.deleter
+    def oauth2_token(self):
+        self._oauth2_token_value = None
+        self._oauth2_token_present = False
+
+    def __repr__(self):
+        return 'TokenFromOAuth1Result(oauth2_token={!r})'.format(
+            self._oauth2_token_value,
+        )
+
+TokenFromOAuth1Result_validator = bv.Struct(TokenFromOAuth1Result)
+
+AccessError._invalid_account_type_validator = InvalidAccountTypeError_validator
+AccessError._paper_access_denied_validator = PaperAccessError_validator
+AccessError._other_validator = bv.Void()
+AccessError._tagmap = {
+    'invalid_account_type': AccessError._invalid_account_type_validator,
+    'paper_access_denied': AccessError._paper_access_denied_validator,
+    'other': AccessError._other_validator,
+}
+
+AccessError.other = AccessError('other')
+
+AuthError._invalid_access_token_validator = bv.Void()
+AuthError._invalid_select_user_validator = bv.Void()
+AuthError._invalid_select_admin_validator = bv.Void()
+AuthError._user_suspended_validator = bv.Void()
+AuthError._other_validator = bv.Void()
+AuthError._tagmap = {
+    'invalid_access_token': AuthError._invalid_access_token_validator,
+    'invalid_select_user': AuthError._invalid_select_user_validator,
+    'invalid_select_admin': AuthError._invalid_select_admin_validator,
+    'user_suspended': AuthError._user_suspended_validator,
+    'other': AuthError._other_validator,
+}
+
+AuthError.invalid_access_token = AuthError('invalid_access_token')
+AuthError.invalid_select_user = AuthError('invalid_select_user')
+AuthError.invalid_select_admin = AuthError('invalid_select_admin')
+AuthError.user_suspended = AuthError('user_suspended')
+AuthError.other = AuthError('other')
+
+InvalidAccountTypeError._endpoint_validator = bv.Void()
+InvalidAccountTypeError._feature_validator = bv.Void()
+InvalidAccountTypeError._other_validator = bv.Void()
+InvalidAccountTypeError._tagmap = {
+    'endpoint': InvalidAccountTypeError._endpoint_validator,
+    'feature': InvalidAccountTypeError._feature_validator,
+    'other': InvalidAccountTypeError._other_validator,
+}
+
+InvalidAccountTypeError.endpoint = InvalidAccountTypeError('endpoint')
+InvalidAccountTypeError.feature = InvalidAccountTypeError('feature')
+InvalidAccountTypeError.other = InvalidAccountTypeError('other')
+
+PaperAccessError._paper_disabled_validator = bv.Void()
+PaperAccessError._not_paper_user_validator = bv.Void()
+PaperAccessError._other_validator = bv.Void()
+PaperAccessError._tagmap = {
+    'paper_disabled': PaperAccessError._paper_disabled_validator,
+    'not_paper_user': PaperAccessError._not_paper_user_validator,
+    'other': PaperAccessError._other_validator,
+}
+
+PaperAccessError.paper_disabled = PaperAccessError('paper_disabled')
+PaperAccessError.not_paper_user = PaperAccessError('not_paper_user')
+PaperAccessError.other = PaperAccessError('other')
+
+RateLimitError._reason_validator = RateLimitReason_validator
+RateLimitError._retry_after_validator = bv.UInt64()
+RateLimitError._all_field_names_ = set([
+    'reason',
+    'retry_after',
+])
+RateLimitError._all_fields_ = [
+    ('reason', RateLimitError._reason_validator),
+    ('retry_after', RateLimitError._retry_after_validator),
+]
+
+RateLimitReason._too_many_requests_validator = bv.Void()
+RateLimitReason._too_many_write_operations_validator = bv.Void()
+RateLimitReason._other_validator = bv.Void()
+RateLimitReason._tagmap = {
+    'too_many_requests': RateLimitReason._too_many_requests_validator,
+    'too_many_write_operations': RateLimitReason._too_many_write_operations_validator,
+    'other': RateLimitReason._other_validator,
+}
+
+RateLimitReason.too_many_requests = RateLimitReason('too_many_requests')
+RateLimitReason.too_many_write_operations = RateLimitReason('too_many_write_operations')
+RateLimitReason.other = RateLimitReason('other')
+
+TokenFromOAuth1Arg._oauth1_token_validator = bv.String(min_length=1)
+TokenFromOAuth1Arg._oauth1_token_secret_validator = bv.String(min_length=1)
+TokenFromOAuth1Arg._all_field_names_ = set([
+    'oauth1_token',
+    'oauth1_token_secret',
+])
+TokenFromOAuth1Arg._all_fields_ = [
+    ('oauth1_token', TokenFromOAuth1Arg._oauth1_token_validator),
+    ('oauth1_token_secret', TokenFromOAuth1Arg._oauth1_token_secret_validator),
+]
+
+TokenFromOAuth1Error._invalid_oauth1_token_info_validator = bv.Void()
+TokenFromOAuth1Error._app_id_mismatch_validator = bv.Void()
+TokenFromOAuth1Error._other_validator = bv.Void()
+TokenFromOAuth1Error._tagmap = {
+    'invalid_oauth1_token_info': TokenFromOAuth1Error._invalid_oauth1_token_info_validator,
+    'app_id_mismatch': TokenFromOAuth1Error._app_id_mismatch_validator,
+    'other': TokenFromOAuth1Error._other_validator,
+}
+
+TokenFromOAuth1Error.invalid_oauth1_token_info = TokenFromOAuth1Error('invalid_oauth1_token_info')
+TokenFromOAuth1Error.app_id_mismatch = TokenFromOAuth1Error('app_id_mismatch')
+TokenFromOAuth1Error.other = TokenFromOAuth1Error('other')
+
+TokenFromOAuth1Result._oauth2_token_validator = bv.String(min_length=1)
+TokenFromOAuth1Result._all_field_names_ = set(['oauth2_token'])
+TokenFromOAuth1Result._all_fields_ = [('oauth2_token', TokenFromOAuth1Result._oauth2_token_validator)]
+
+token_from_oauth1 = bb.Route(
+    'token/from_oauth1',
+    False,
+    TokenFromOAuth1Arg_validator,
+    TokenFromOAuth1Result_validator,
+    TokenFromOAuth1Error_validator,
+    {'host': u'api',
+     'style': u'rpc'},
+)
+token_revoke = bb.Route(
+    'token/revoke',
+    False,
+    bv.Void(),
+    bv.Void(),
+    bv.Void(),
+    {'host': u'api',
+     'style': u'rpc'},
+)
+
+ROUTES = {
+    'token/from_oauth1': token_from_oauth1,
+    'token/revoke': token_revoke,
+}
+

resources/lib/dropbox/common.py

@@ -0,0 +1,323 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+class InvalidPathRootError(object):
+    """
+    :ivar path_root: The latest path root id for user's team if the user is
+        still in a team.
+    """
+
+    __slots__ = [
+        '_path_root_value',
+        '_path_root_present',
+    ]
+
+    _has_required_fields = False
+
+    def __init__(self,
+                 path_root=None):
+        self._path_root_value = None
+        self._path_root_present = False
+        if path_root is not None:
+            self.path_root = path_root
+
+    @property
+    def path_root(self):
+        """
+        The latest path root id for user's team if the user is still in a team.
+
+        :rtype: str
+        """
+        if self._path_root_present:
+            return self._path_root_value
+        else:
+            return None
+
+    @path_root.setter
+    def path_root(self, val):
+        if val is None:
+            del self.path_root
+            return
+        val = self._path_root_validator.validate(val)
+        self._path_root_value = val
+        self._path_root_present = True
+
+    @path_root.deleter
+    def path_root(self):
+        self._path_root_value = None
+        self._path_root_present = False
+
+    def __repr__(self):
+        return 'InvalidPathRootError(path_root={!r})'.format(
+            self._path_root_value,
+        )
+
+InvalidPathRootError_validator = bv.Struct(InvalidPathRootError)
+
+class PathRoot(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar home: Paths are relative to the authenticating user's home directory,
+        whether or not that user belongs to a team.
+    :ivar member_home: Paths are relative to the authenticating team member's
+        home directory. (This results in ``PathRootError.invalid`` if the user
+        does not belong to a team.).
+    :ivar str team: Paths are relative to the given team directory. (This
+        results in :field:`PathRootError.invalid` if the user is not a member of
+        the team associated with that path root id.).
+    :ivar user_home: Paths are relative to the user's home directory. (This
+        results in ``PathRootError.invalid`` if the belongs to a team.).
+    :ivar str namespace_id: Paths are relative to given namespace id (This
+        results in :field:`PathRootError.no_permission` if you don't have access
+        to this namespace.).
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    home = None
+    # Attribute is overwritten below the class definition
+    member_home = None
+    # Attribute is overwritten below the class definition
+    user_home = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    @classmethod
+    def team(cls, val):
+        """
+        Create an instance of this class set to the ``team`` tag with value
+        ``val``.
+
+        :param str val:
+        :rtype: PathRoot
+        """
+        return cls('team', val)
+
+    @classmethod
+    def namespace_id(cls, val):
+        """
+        Create an instance of this class set to the ``namespace_id`` tag with
+        value ``val``.
+
+        :param str val:
+        :rtype: PathRoot
+        """
+        return cls('namespace_id', val)
+
+    def is_home(self):
+        """
+        Check if the union tag is ``home``.
+
+        :rtype: bool
+        """
+        return self._tag == 'home'
+
+    def is_member_home(self):
+        """
+        Check if the union tag is ``member_home``.
+
+        :rtype: bool
+        """
+        return self._tag == 'member_home'
+
+    def is_team(self):
+        """
+        Check if the union tag is ``team``.
+
+        :rtype: bool
+        """
+        return self._tag == 'team'
+
+    def is_user_home(self):
+        """
+        Check if the union tag is ``user_home``.
+
+        :rtype: bool
+        """
+        return self._tag == 'user_home'
+
+    def is_namespace_id(self):
+        """
+        Check if the union tag is ``namespace_id``.
+
+        :rtype: bool
+        """
+        return self._tag == 'namespace_id'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def get_team(self):
+        """
+        Paths are relative to the given team directory. (This results in
+        ``PathRootError.invalid`` if the user is not a member of the team
+        associated with that path root id.).
+
+        Only call this if :meth:`is_team` is true.
+
+        :rtype: str
+        """
+        if not self.is_team():
+            raise AttributeError("tag 'team' not set")
+        return self._value
+
+    def get_namespace_id(self):
+        """
+        Paths are relative to given namespace id (This results in
+        ``PathRootError.no_permission`` if you don't have access to this
+        namespace.).
+
+        Only call this if :meth:`is_namespace_id` is true.
+
+        :rtype: str
+        """
+        if not self.is_namespace_id():
+            raise AttributeError("tag 'namespace_id' not set")
+        return self._value
+
+    def __repr__(self):
+        return 'PathRoot(%r, %r)' % (self._tag, self._value)
+
+PathRoot_validator = bv.Union(PathRoot)
+
+class PathRootError(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar InvalidPathRootError invalid: The path root id value in
+        Dropbox-API-Path-Root header is no longer valid.
+    :ivar no_permission: You don't have permission to access the path root id in
+        Dropbox-API-Path-Root  header.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    no_permission = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    @classmethod
+    def invalid(cls, val):
+        """
+        Create an instance of this class set to the ``invalid`` tag with value
+        ``val``.
+
+        :param InvalidPathRootError val:
+        :rtype: PathRootError
+        """
+        return cls('invalid', val)
+
+    def is_invalid(self):
+        """
+        Check if the union tag is ``invalid``.
+
+        :rtype: bool
+        """
+        return self._tag == 'invalid'
+
+    def is_no_permission(self):
+        """
+        Check if the union tag is ``no_permission``.
+
+        :rtype: bool
+        """
+        return self._tag == 'no_permission'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def get_invalid(self):
+        """
+        The path root id value in Dropbox-API-Path-Root header is no longer
+        valid.
+
+        Only call this if :meth:`is_invalid` is true.
+
+        :rtype: InvalidPathRootError
+        """
+        if not self.is_invalid():
+            raise AttributeError("tag 'invalid' not set")
+        return self._value
+
+    def __repr__(self):
+        return 'PathRootError(%r, %r)' % (self._tag, self._value)
+
+PathRootError_validator = bv.Union(PathRootError)
+
+Date_validator = bv.Timestamp(u'%Y-%m-%d')
+DisplayName_validator = bv.String(min_length=1, pattern=u'[^/:?*<>"|]*')
+DisplayNameLegacy_validator = bv.String(min_length=1)
+DropboxTimestamp_validator = bv.Timestamp(u'%Y-%m-%dT%H:%M:%SZ')
+EmailAddress_validator = bv.String(max_length=255, pattern=u"^['&A-Za-z0-9._%+-]+@[A-Za-z0-9-][A-Za-z0-9.-]*.[A-Za-z]{2,15}$")
+# A ISO639-1 code.
+LanguageCode_validator = bv.String(min_length=2)
+NamePart_validator = bv.String(min_length=1, max_length=100, pattern=u'[^/:?*<>"|]*')
+NamespaceId_validator = bv.String(pattern=u'[-_0-9a-zA-Z:]+')
+OptionalNamePart_validator = bv.String(max_length=100, pattern=u'[^/:?*<>"|]*')
+PathRootId_validator = NamespaceId_validator
+SessionId_validator = bv.String()
+SharedFolderId_validator = NamespaceId_validator
+InvalidPathRootError._path_root_validator = bv.Nullable(PathRootId_validator)
+InvalidPathRootError._all_field_names_ = set(['path_root'])
+InvalidPathRootError._all_fields_ = [('path_root', InvalidPathRootError._path_root_validator)]
+
+PathRoot._home_validator = bv.Void()
+PathRoot._member_home_validator = bv.Void()
+PathRoot._team_validator = PathRootId_validator
+PathRoot._user_home_validator = bv.Void()
+PathRoot._namespace_id_validator = PathRootId_validator
+PathRoot._other_validator = bv.Void()
+PathRoot._tagmap = {
+    'home': PathRoot._home_validator,
+    'member_home': PathRoot._member_home_validator,
+    'team': PathRoot._team_validator,
+    'user_home': PathRoot._user_home_validator,
+    'namespace_id': PathRoot._namespace_id_validator,
+    'other': PathRoot._other_validator,
+}
+
+PathRoot.home = PathRoot('home')
+PathRoot.member_home = PathRoot('member_home')
+PathRoot.user_home = PathRoot('user_home')
+PathRoot.other = PathRoot('other')
+
+PathRootError._invalid_validator = InvalidPathRootError_validator
+PathRootError._no_permission_validator = bv.Void()
+PathRootError._other_validator = bv.Void()
+PathRootError._tagmap = {
+    'invalid': PathRootError._invalid_validator,
+    'no_permission': PathRootError._no_permission_validator,
+    'other': PathRootError._other_validator,
+}
+
+PathRootError.no_permission = PathRootError('no_permission')
+PathRootError.other = PathRootError('other')
+
+ROUTES = {
+}
+

resources/lib/dropbox/dropbox.py

@@ -0,0 +1,515 @@
+__all__ = [
+    'Dropbox',
+    'DropboxTeam',
+    'create_session',
+]
+
+# This should always be 0.0.0 in master. Only update this after tagging
+# before release.
+__version__ = '0.0.0'
+
+import contextlib
+import json
+import logging
+import random
+import time
+
+import requests
+import six
+
+from . import files, stone_serializers
+from .auth import (
+    AuthError_validator,
+    RateLimitError_validator,
+)
+from .base import DropboxBase
+from .base_team import DropboxTeamBase
+from .exceptions import (
+    ApiError,
+    AuthError,
+    BadInputError,
+    HttpError,
+    InternalServerError,
+    RateLimitError,
+)
+from .session import (
+    API_HOST,
+    API_CONTENT_HOST,
+    API_NOTIFICATION_HOST,
+    HOST_API,
+    HOST_CONTENT,
+    HOST_NOTIFY,
+    pinned_session,
+)
+
+class RouteResult(object):
+    """The successful result of a call to a route."""
+
+    def __init__(self, obj_result, http_resp=None):
+        """
+        :param str obj_result: The result of a route not including the binary
+            payload portion, if one exists. Must be serialized JSON.
+        :param requests.models.Response http_resp: A raw HTTP response. It will
+            be used to stream the binary-body payload of the response.
+        """
+        assert isinstance(obj_result, six.string_types), \
+            'obj_result: expected string, got %r' % type(obj_result)
+        if http_resp is not None:
+            assert isinstance(http_resp, requests.models.Response), \
+                'http_resp: expected requests.models.Response, got %r' % \
+                type(http_resp)
+        self.obj_result = obj_result
+        self.http_resp = http_resp
+
+class RouteErrorResult(object):
+    """The error result of a call to a route."""
+
+    def __init__(self, request_id, obj_result):
+        """
+        :param str request_id: A request_id can be shared with Dropbox Support
+            to pinpoint the exact request that returns an error.
+        :param str obj_result: The result of a route not including the binary
+            payload portion, if one exists.
+        """
+        self.request_id = request_id
+        self.obj_result = obj_result
+
+def create_session(max_connections=8, proxies=None):
+    """
+    Creates a session object that can be used by multiple :class:`Dropbox` and
+    :class:`DropboxTeam` instances. This lets you share a connection pool
+    amongst them, as well as proxy parameters.
+
+    :param int max_connections: Maximum connection pool size.
+    :param dict proxies: See the `requests module
+            <http://docs.python-requests.org/en/latest/user/advanced/#proxies>`_
+            for more details.
+    :rtype: :class:`requests.sessions.Session`. `See the requests module
+        <http://docs.python-requests.org/en/latest/user/advanced/#session-objects>`_
+        for more details.
+    """
+    # We only need as many pool_connections as we have unique hostnames.
+    session = pinned_session(pool_maxsize=max_connections)
+    if proxies:
+        session.proxies = proxies
+    return session
+
+class _DropboxTransport(object):
+    """
+    Responsible for implementing the wire protocol for making requests to the
+    Dropbox API.
+    """
+
+    _API_VERSION = '2'
+
+    # Download style means that the route argument goes in a Dropbox-API-Arg
+    # header, and the result comes back in a Dropbox-API-Result header. The
+    # HTTP response body contains a binary payload.
+    _ROUTE_STYLE_DOWNLOAD = 'download'
+
+    # Upload style means that the route argument goes in a Dropbox-API-Arg
+    # header. The HTTP request body contains a binary payload. The result
+    # comes back in a Dropbox-API-Result header.
+    _ROUTE_STYLE_UPLOAD = 'upload'
+
+    # RPC style means that the argument and result of a route are contained in
+    # the HTTP body.
+    _ROUTE_STYLE_RPC = 'rpc'
+
+    # This is the default longest time we'll block on receiving data from the server
+    _DEFAULT_TIMEOUT = 30
+
+    def __init__(self,
+                 oauth2_access_token,
+                 max_retries_on_error=4,
+                 max_retries_on_rate_limit=None,
+                 user_agent=None,
+                 session=None,
+                 headers=None,
+                 timeout=_DEFAULT_TIMEOUT):
+        """
+        :param str oauth2_access_token: OAuth2 access token for making client
+            requests.
+
+        :param int max_retries_on_error: On 5xx errors, the number of times to
+            retry.
+        :param Optional[int] max_retries_on_rate_limit: On 429 errors, the
+            number of times to retry. If `None`, always retries.
+        :param str user_agent: The user agent to use when making requests. This
+            helps us identify requests coming from your application. We
+            recommend you use the format "AppName/Version". If set, we append
+            "/OfficialDropboxPythonSDKv2/__version__" to the user_agent,
+        :param session: If not provided, a new session (connection pool) is
+            created. To share a session across multiple clients, use
+            :func:`create_session`.
+        :type session: :class:`requests.sessions.Session`
+        :param dict headers: Additional headers to add to requests.
+        :param Optional[float] timeout: Maximum duration in seconds that
+            client will wait for any single packet from the
+            server. After the timeout the client will give up on
+            connection. If `None`, client will wait forever. Defaults
+            to 30 seconds.
+        """
+        assert len(oauth2_access_token) > 0, \
+            'OAuth2 access token cannot be empty.'
+        assert headers is None or isinstance(headers, dict), \
+            'Expected dict, got %r' % headers
+        self._oauth2_access_token = oauth2_access_token
+
+        self._max_retries_on_error = max_retries_on_error
+        self._max_retries_on_rate_limit = max_retries_on_rate_limit
+        if session:
+            assert isinstance(session, requests.sessions.Session), \
+                'Expected requests.sessions.Session, got %r' % session
+            self._session = session
+        else:
+            self._session = create_session()
+        self._headers = headers
+
+        base_user_agent = 'OfficialDropboxPythonSDKv2/' + __version__
+        if user_agent:
+            self._raw_user_agent = user_agent
+            self._user_agent = '{}/{}'.format(user_agent, base_user_agent)
+        else:
+            self._raw_user_agent = None
+            self._user_agent = base_user_agent
+
+        self._logger = logging.getLogger('dropbox')
+
+        self._host_map = {HOST_API: API_HOST,
+                          HOST_CONTENT: API_CONTENT_HOST,
+                          HOST_NOTIFY: API_NOTIFICATION_HOST}
+
+        self._timeout = timeout
+
+    def request(self,
+                route,
+                namespace,
+                request_arg,
+                request_binary,
+                timeout=None):
+        """
+        Makes a request to the Dropbox API and in the process validates that
+        the route argument and result are the expected data types. The
+        request_arg is converted to JSON based on the arg_data_type. Likewise,
+        the response is deserialized from JSON and converted to an object based
+        on the {result,error}_data_type.
+
+        :param host: The Dropbox API host to connect to.
+        :param route: The route to make the request to.
+        :type route: :class:`.datatypes.stone_base.Route`
+        :param request_arg: Argument for the route that conforms to the
+            validator specified by route.arg_type.
+        :param request_binary: String or file pointer representing the binary
+            payload. Use None if there is no binary payload.
+        :param Optional[float] timeout: Maximum duration in seconds
+            that client will wait for any single packet from the
+            server. After the timeout the client will give up on
+            connection. If `None`, will use default timeout set on
+            Dropbox object.  Defaults to `None`.
+        :return: The route's result.
+        """
+        host = route.attrs['host'] or 'api'
+        route_name = namespace + '/' + route.name
+        route_style = route.attrs['style'] or 'rpc'
+        serialized_arg = stone_serializers.json_encode(route.arg_type,
+                                                       request_arg)
+
+        if (timeout is None and
+                route == files.list_folder_longpoll):
+            # The client normally sends a timeout value to the
+            # longpoll route. The server will respond after
+            # <timeout> + random(0, 90) seconds. We increase the
+            # socket timeout to the longpoll timeout value plus 90
+            # seconds so that we don't cut the server response short
+            # due to a shorter socket timeout.
+            # NB: This is done here because base.py is auto-generated
+            timeout = request_arg.timeout + 90
+
+        res = self.request_json_string_with_retry(host,
+                                                  route_name,
+                                                  route_style,
+                                                  serialized_arg,
+                                                  request_binary,
+                                                  timeout=timeout)
+        decoded_obj_result = json.loads(res.obj_result)
+        if isinstance(res, RouteResult):
+            returned_data_type = route.result_type
+            obj = decoded_obj_result
+        elif isinstance(res, RouteErrorResult):
+            returned_data_type = route.error_type
+            obj = decoded_obj_result['error']
+            user_message = decoded_obj_result.get('user_message')
+            user_message_text = user_message and user_message.get('text')
+            user_message_locale = user_message and user_message.get('locale')
+        else:
+            raise AssertionError('Expected RouteResult or RouteErrorResult, '
+                                 'but res is %s' % type(res))
+
+        deserialized_result = stone_serializers.json_compat_obj_decode(
+            returned_data_type, obj, strict=False)
+
+        if isinstance(res, RouteErrorResult):
+            raise ApiError(res.request_id,
+                           deserialized_result,
+                           user_message_text,
+                           user_message_locale)
+        elif route_style == self._ROUTE_STYLE_DOWNLOAD:
+            return (deserialized_result, res.http_resp)
+        else:
+            return deserialized_result
+
+    def request_json_object(self,
+                            host,
+                            route_name,
+                            route_style,
+                            request_arg,
+                            request_binary,
+                            timeout=None):
+        """
+        Makes a request to the Dropbox API, taking a JSON-serializable Python
+        object as an argument, and returning one as a response.
+
+        :param host: The Dropbox API host to connect to.
+        :param route_name: The name of the route to invoke.
+        :param route_style: The style of the route.
+        :param str request_arg: A JSON-serializable Python object representing
+            the argument for the route.
+        :param Optional[bytes] request_binary: Bytes representing the binary
+            payload. Use None if there is no binary payload.
+        :param Optional[float] timeout: Maximum duration in seconds
+            that client will wait for any single packet from the
+            server. After the timeout the client will give up on
+            connection. If `None`, will use default timeout set on
+            Dropbox object.  Defaults to `None`.
+        :return: The route's result as a JSON-serializable Python object.
+        """
+        serialized_arg = json.dumps(request_arg)
+        res = self.request_json_string_with_retry(host,
+                                                  route_name,
+                                                  route_style,
+                                                  serialized_arg,
+                                                  request_binary,
+                                                  timeout=timeout)
+        # This can throw a ValueError if the result is not deserializable,
+        # but that would be completely unexpected.
+        deserialized_result = json.loads(res.obj_result)
+        if isinstance(res, RouteResult) and res.http_resp is not None:
+            return (deserialized_result, res.http_resp)
+        else:
+            return deserialized_result
+
+    def request_json_string_with_retry(self,
+                                       host,
+                                       route_name,
+                                       route_style,
+                                       request_json_arg,
+                                       request_binary,
+                                       timeout=None):
+        """
+        See :meth:`request_json_object` for description of parameters.
+
+        :param request_json_arg: A string representing the serialized JSON
+            argument to the route.
+        """
+        attempt = 0
+        rate_limit_errors = 0
+        while True:
+            self._logger.info('Request to %s', route_name)
+            try:
+                return self.request_json_string(host,
+                                                route_name,
+                                                route_style,
+                                                request_json_arg,
+                                                request_binary,
+                                                timeout=timeout)
+            except InternalServerError as e:
+                attempt += 1
+                if attempt <= self._max_retries_on_error:
+                    # Use exponential backoff
+                    backoff = 2**attempt * random.random()
+                    self._logger.info(
+                        'HttpError status_code=%s: Retrying in %.1f seconds',
+                        e.status_code, backoff)
+                    time.sleep(backoff)
+                else:
+                    raise
+            except RateLimitError as e:
+                rate_limit_errors += 1
+                if (self._max_retries_on_rate_limit is None or
+                        self._max_retries_on_rate_limit >= rate_limit_errors):
+                    # Set default backoff to 5 seconds.
+                    backoff = e.backoff if e.backoff is not None else 5.0
+                    self._logger.info(
+                        'Ratelimit: Retrying in %.1f seconds.', backoff)
+                    time.sleep(backoff)
+                else:
+                    raise
+
+    def request_json_string(self,
+                            host,
+                            func_name,
+                            route_style,
+                            request_json_arg,
+                            request_binary,
+                            timeout=None):
+        """
+        See :meth:`request_json_string_with_retry` for description of
+        parameters.
+        """
+        if host not in self._host_map:
+            raise ValueError('Unknown value for host: %r' % host)
+
+        if not isinstance(request_binary, (six.binary_type, type(None))):
+            # Disallow streams and file-like objects even though the underlying
+            # requests library supports them. This is to prevent incorrect
+            # behavior when a non-rewindable stream is read from, but the
+            # request fails and needs to be re-tried at a later time.
+            raise TypeError('expected request_binary as binary type, got %s' %
+                            type(request_binary))
+
+        # Fully qualified hostname
+        fq_hostname = self._host_map[host]
+        url = self._get_route_url(fq_hostname, func_name)
+
+        headers = {'User-Agent': self._user_agent}
+        if host != HOST_NOTIFY:
+            headers['Authorization'] = 'Bearer %s' % self._oauth2_access_token
+            if self._headers:
+                headers.update(self._headers)
+
+        # The contents of the body of the HTTP request
+        body = None
+        # Whether the response should be streamed incrementally, or buffered
+        # entirely. If stream is True, the caller is responsible for closing
+        # the HTTP response.
+        stream = False
+
+        if route_style == self._ROUTE_STYLE_RPC:
+            headers['Content-Type'] = 'application/json'
+            body = request_json_arg
+        elif route_style == self._ROUTE_STYLE_DOWNLOAD:
+            headers['Dropbox-API-Arg'] = request_json_arg
+            stream = True
+        elif route_style == self._ROUTE_STYLE_UPLOAD:
+            headers['Content-Type'] = 'application/octet-stream'
+            headers['Dropbox-API-Arg'] = request_json_arg
+            body = request_binary
+        else:
+            raise ValueError('Unknown operation style: %r' % route_style)
+
+        if timeout is None:
+            timeout = self._timeout
+
+        r = self._session.post(url,
+                               headers=headers,
+                               data=body,
+                               stream=stream,
+                               verify=True,
+                               timeout=timeout,
+                               )
+
+        request_id = r.headers.get('x-dropbox-request-id')
+        if r.status_code >= 500:
+            raise InternalServerError(request_id, r.status_code, r.text)
+        elif r.status_code == 400:
+            raise BadInputError(request_id, r.text)
+        elif r.status_code == 401:
+            assert r.headers.get('content-type') == 'application/json', (
+                'Expected content-type to be application/json, got %r' %
+                r.headers.get('content-type'))
+            err = stone_serializers.json_compat_obj_decode(
+                AuthError_validator, r.json()['error'])
+            raise AuthError(request_id, err)
+        elif r.status_code == 429:
+            err = None
+            if r.headers.get('content-type') == 'application/json':
+                err = stone_serializers.json_compat_obj_decode(
+                    RateLimitError_validator, r.json()['error'])
+                retry_after = err.retry_after
+            else:
+                retry_after_str = r.headers.get('retry-after')
+                if retry_after_str is not None:
+                    retry_after = int(retry_after_str)
+                else:
+                    retry_after = None
+            raise RateLimitError(request_id, err, retry_after)
+        elif 200 <= r.status_code <= 299:
+            if route_style == self._ROUTE_STYLE_DOWNLOAD:
+                raw_resp = r.headers['dropbox-api-result']
+            else:
+                assert r.headers.get('content-type') == 'application/json', (
+                    'Expected content-type to be application/json, got %r' %
+                    r.headers.get('content-type'))
+                raw_resp = r.content.decode('utf-8')
+            if route_style == self._ROUTE_STYLE_DOWNLOAD:
+                return RouteResult(raw_resp, r)
+            else:
+                return RouteResult(raw_resp)
+        elif r.status_code in (403, 404, 409):
+            raw_resp = r.content.decode('utf-8')
+            return RouteErrorResult(request_id, raw_resp)
+        else:
+            raise HttpError(request_id, r.status_code, r.text)
+
+    def _get_route_url(self, hostname, route_name):
+        """Returns the URL of the route.
+
+        :param str hostname: Hostname to make the request to.
+        :param str route_name: Name of the route.
+        :rtype: str
+        """
+        return 'https://{hostname}/{version}/{route_name}'.format(
+            hostname=hostname,
+            version=Dropbox._API_VERSION,
+            route_name=route_name,
+        )
+
+    def _save_body_to_file(self, download_path, http_resp, chunksize=2**16):
+        """
+        Saves the body of an HTTP response to a file.
+
+        :param str download_path: Local path to save data to.
+        :param http_resp: The HTTP response whose body will be saved.
+        :type http_resp: :class:`requests.models.Response`
+        :rtype: None
+        """
+        with open(download_path, 'wb') as f:
+            with contextlib.closing(http_resp):
+                for c in http_resp.iter_content(chunksize):
+                    f.write(c)
+
+class Dropbox(_DropboxTransport, DropboxBase):
+    """
+    Use this class to make requests to the Dropbox API using a user's access
+    token. Methods of this class are meant to act on the corresponding user's
+    Dropbox.
+    """
+    pass
+
+class DropboxTeam(_DropboxTransport, DropboxTeamBase):
+    """
+    Use this class to make requests to the Dropbox API using a team's access
+    token. Methods of this class are meant to act on the team, but there is
+    also an :meth:`as_user` method for assuming a team member's identity.
+    """
+
+    def as_user(self, team_member_id):
+        """
+        Allows a team credential to assume the identity of a member of the
+        team.
+
+        :return: A :class:`Dropbox` object that can be used to query on behalf
+            of this member of the team.
+        :rtype: Dropbox
+        """
+        new_headers = self._headers.copy() if self._headers else {}
+        new_headers['Dropbox-API-Select-User'] = team_member_id
+        return Dropbox(
+            self._oauth2_access_token,
+            max_retries_on_error=self._max_retries_on_error,
+            max_retries_on_rate_limit=self._max_retries_on_rate_limit,
+            user_agent=self._raw_user_agent,
+            session=self._session,
+            headers=new_headers,
+        )

resources/lib/dropbox/exceptions.py

@@ -0,0 +1,89 @@
+class DropboxException(Exception):
+    """All errors related to making an API request extend this."""
+
+    def __init__(self, request_id, *args, **kwargs):
+        # A request_id can be shared with Dropbox Support to pinpoint the exact
+        # request that returns an error.
+        super(DropboxException, self).__init__(request_id, *args, **kwargs)
+        self.request_id = request_id
+
+    def __str__(self):
+        return repr(self)
+
+
+class ApiError(DropboxException):
+    """Errors produced by the Dropbox API."""
+
+    def __init__(self, request_id, error, user_message_text, user_message_locale):
+        """
+        :param (str) request_id: A request_id can be shared with Dropbox
+            Support to pinpoint the exact request that returns an error.
+        :param error: An instance of the error data type for the route.
+        :param (str) user_message_text: A human-readable message that can be
+            displayed to the end user. Is None, if unavailable.
+        :param (str) user_message_locale: The locale of ``user_message_text``,
+            if present.
+        """
+        super(ApiError, self).__init__(request_id, error)
+        self.error = error
+        self.user_message_text = user_message_text
+        self.user_message_locale = user_message_locale
+
+    def __repr__(self):
+        return 'ApiError({!r}, {})'.format(self.request_id, self.error)
+
+
+class HttpError(DropboxException):
+    """Errors produced at the HTTP layer."""
+
+    def __init__(self, request_id, status_code, body):
+        super(HttpError, self).__init__(request_id, status_code, body)
+        self.status_code = status_code
+        self.body = body
+
+    def __repr__(self):
+        return 'HttpError({!r}, {}, {!r})'.format(self.request_id,
+            self.status_code, self.body)
+
+
+class BadInputError(HttpError):
+    """Errors due to bad input parameters to an API Operation."""
+
+    def __init__(self, request_id, message):
+        super(BadInputError, self).__init__(request_id, 400, message)
+        self.message = message
+
+    def __repr__(self):
+        return 'BadInputError({!r}, {!r})'.format(self.request_id, self.message)
+
+
+class AuthError(HttpError):
+    """Errors due to invalid authentication credentials."""
+
+    def __init__(self, request_id, error):
+        super(AuthError, self).__init__(request_id, 401, None)
+        self.error = error
+
+    def __repr__(self):
+        return 'AuthError({!r}, {!r})'.format(self.request_id, self.error)
+
+
+class RateLimitError(HttpError):
+    """Error caused by rate limiting."""
+
+    def __init__(self, request_id, error=None, backoff=None):
+        super(RateLimitError, self).__init__(request_id, 429, None)
+        self.error = error
+        self.backoff = backoff
+
+    def __repr__(self):
+        return 'RateLimitError({!r}, {!r}, {!r})'.format(
+            self.request_id, self.error, self.backoff)
+
+
+class InternalServerError(HttpError):
+    """Errors due to a problem on Dropbox."""
+
+    def __repr__(self):
+        return 'InternalServerError({!r}, {}, {!r})'.format(
+            self.request_id, self.status_code, self.body)

resources/lib/dropbox/oauth.py

@@ -0,0 +1,515 @@
+__all__ = [
+    'BadRequestException',
+    'BadStateException',
+    'CsrfException',
+    'DropboxOAuth2Flow',
+    'DropboxOAuth2FlowNoRedirect',
+    'NotApprovedException',
+    'OAuth2FlowNoRedirectResult',
+    'OAuth2FlowResult',
+    'ProviderException',
+]
+
+import base64
+import os
+import six
+import urllib
+
+from .session import (
+    API_HOST,
+    WEB_HOST,
+    pinned_session,
+)
+
+if six.PY3:
+    url_path_quote = urllib.parse.quote  # pylint: disable=no-member,useless-suppression
+    url_encode = urllib.parse.urlencode  # pylint: disable=no-member,useless-suppression
+else:
+    url_path_quote = urllib.quote  # pylint: disable=no-member,useless-suppression
+    url_encode = urllib.urlencode  # pylint: disable=no-member,useless-suppression
+
+
+class OAuth2FlowNoRedirectResult(object):
+    """
+    Authorization information for an OAuth2Flow performed with no redirect.
+    """
+
+    def __init__(self, access_token, account_id, user_id):
+        """
+        Args:
+            access_token (str): Token to be used to authenticate later
+                requests.
+            account_id (str): The Dropbox user's account ID.
+            user_id (str): Deprecated (use account_id instead).
+        """
+        self.access_token = access_token
+        self.account_id = account_id
+        self.user_id = user_id
+
+    def __repr__(self):
+        return 'OAuth2FlowNoRedirectResult(%r, %r, %r)' % (
+            self.access_token,
+            self.account_id,
+            self.user_id,
+        )
+
+
+class OAuth2FlowResult(OAuth2FlowNoRedirectResult):
+    """
+    Authorization information for an OAuth2Flow with redirect.
+    """
+
+    def __init__(self, access_token, account_id, user_id, url_state):
+        """
+        Same as OAuth2FlowNoRedirectResult but with url_state.
+
+        Args:
+            url_state (str): The url state that was set by
+                :meth:`DropboxOAuth2Flow.start`.
+        """
+        super(OAuth2FlowResult, self).__init__(
+            access_token, account_id, user_id)
+        self.url_state = url_state
+
+    @classmethod
+    def from_no_redirect_result(cls, result, url_state):
+        assert isinstance(result, OAuth2FlowNoRedirectResult)
+        return cls(
+            result.access_token, result.account_id, result.user_id, url_state)
+
+    def __repr__(self):
+        return 'OAuth2FlowResult(%r, %r, %r, %r)' % (
+            self.access_token,
+            self.account_id,
+            self.user_id,
+            self.url_state,
+        )
+
+
+class DropboxOAuth2FlowBase(object):
+
+    def __init__(self, consumer_key, consumer_secret, locale=None):
+        self.consumer_key = consumer_key
+        self.consumer_secret = consumer_secret
+        self.locale = locale
+        self.requests_session = pinned_session()
+
+    def _get_authorize_url(self, redirect_uri, state):
+        params = dict(response_type='code',
+                      client_id=self.consumer_key)
+        if redirect_uri is not None:
+            params['redirect_uri'] = redirect_uri
+        if state is not None:
+            params['state'] = state
+
+        return self.build_url('/oauth2/authorize', params, WEB_HOST)
+
+    def _finish(self, code, redirect_uri):
+        url = self.build_url('/oauth2/token')
+        params = {'grant_type': 'authorization_code',
+                  'code': code,
+                  'client_id': self.consumer_key,
+                  'client_secret': self.consumer_secret,
+                  }
+        if self.locale is not None:
+            params['locale'] = self.locale
+        if redirect_uri is not None:
+            params['redirect_uri'] = redirect_uri
+
+        resp = self.requests_session.post(url, data=params)
+        resp.raise_for_status()
+
+        d = resp.json()
+
+        if 'team_id' in d:
+            account_id = d['team_id']
+        else:
+            account_id = d['account_id']
+
+        access_token = d['access_token']
+        uid = d['uid']
+
+        return OAuth2FlowNoRedirectResult(
+            access_token,
+            account_id,
+            uid)
+
+    def build_path(self, target, params=None):
+        """Build the path component for an API URL.
+
+        This method urlencodes the parameters, adds them
+        to the end of the target url, and puts a marker for the API
+        version in front.
+
+        :param str target: A target url (e.g. '/files') to build upon.
+        :param dict params: Optional dictionary of parameters (name to value).
+        :return: The path and parameters components of an API URL.
+        :rtype: str
+        """
+        if six.PY2 and isinstance(target, six.text_type):
+            target = target.encode('utf8')
+
+        target_path = url_path_quote(target)
+
+        params = params or {}
+        params = params.copy()
+
+        if self.locale:
+            params['locale'] = self.locale
+
+        if params:
+            query_string = _params_to_urlencoded(params)
+            return "%s?%s" % (target_path, query_string)
+        else:
+            return target_path
+
+    def build_url(self, target, params=None, host=API_HOST):
+        """Build an API URL.
+
+        This method adds scheme and hostname to the path
+        returned from build_path.
+
+        :param str target: A target url (e.g. '/files') to build upon.
+        :param dict params: Optional dictionary of parameters (name to value).
+        :return: The full API URL.
+        :rtype: str
+        """
+        return "https://%s%s" % (host, self.build_path(target, params))
+
+
+class DropboxOAuth2FlowNoRedirect(DropboxOAuth2FlowBase):
+    """
+    OAuth 2 authorization helper for apps that can't provide a redirect URI
+    (such as the command-line example apps).
+
+    Example::
+
+        from dropbox import DropboxOAuth2FlowNoRedirect
+
+        auth_flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
+
+        authorize_url = auth_flow.start()
+        print "1. Go to: " + authorize_url
+        print "2. Click \\"Allow\\" (you might have to log in first)."
+        print "3. Copy the authorization code."
+        auth_code = raw_input("Enter the authorization code here: ").strip()
+
+        try:
+            oauth_result = auth_flow.finish(auth_code)
+        except Exception, e:
+            print('Error: %s' % (e,))
+            return
+
+        dbx = Dropbox(oauth_result.access_token)
+    """
+
+    def __init__(self, consumer_key, consumer_secret, locale=None):  # noqa: E501; pylint: disable=useless-super-delegation
+        """
+        Construct an instance.
+
+        Parameters
+        :param str consumer_key: Your API app's "app key".
+        :param str consumer_secret: Your API app's "app secret".
+        :param str locale: The locale of the user of your application.  For
+            example "en" or "en_US". Some API calls return localized data and
+            error messages; this setting tells the server which locale to use.
+            By default, the server uses "en_US".
+        """
+        # pylint: disable=useless-super-delegation
+        super(DropboxOAuth2FlowNoRedirect, self).__init__(
+            consumer_key,
+            consumer_secret,
+            locale,
+        )
+
+    def start(self):
+        """
+        Starts the OAuth 2 authorization process.
+
+        :return: The URL for a page on Dropbox's website.  This page will let
+            the user "approve" your app, which gives your app permission to
+            access the user's Dropbox account. Tell the user to visit this URL
+            and approve your app.
+        """
+        return self._get_authorize_url(None, None)
+
+    def finish(self, code):
+        """
+        If the user approves your app, they will be presented with an
+        "authorization code".  Have the user copy/paste that authorization code
+        into your app and then call this method to get an access token.
+
+        :param str code: The authorization code shown to the user when they
+            approved your app.
+        :rtype: OAuth2FlowNoRedirectResult
+        :raises: The same exceptions as :meth:`DropboxOAuth2Flow.finish()`.
+        """
+        return self._finish(code, None)
+
+
+class DropboxOAuth2Flow(DropboxOAuth2FlowBase):
+    """
+    OAuth 2 authorization helper.  Use this for web apps.
+
+    OAuth 2 has a two-step authorization process.  The first step is having the
+    user authorize your app.  The second involves getting an OAuth 2 access
+    token from Dropbox.
+
+    Example::
+
+        from dropbox import DropboxOAuth2Flow
+
+        def get_dropbox_auth_flow(web_app_session):
+            redirect_uri = "https://my-web-server.org/dropbox-auth-finish"
+            return DropboxOAuth2Flow(
+                APP_KEY, APP_SECRET, redirect_uri, web_app_session,
+                "dropbox-auth-csrf-token")
+
+        # URL handler for /dropbox-auth-start
+        def dropbox_auth_start(web_app_session, request):
+            authorize_url = get_dropbox_auth_flow(web_app_session).start()
+            redirect_to(authorize_url)
+
+        # URL handler for /dropbox-auth-finish
+        def dropbox_auth_finish(web_app_session, request):
+            try:
+                oauth_result = \\
+                        get_dropbox_auth_flow(web_app_session).finish(
+                            request.query_params)
+            except BadRequestException, e:
+                http_status(400)
+            except BadStateException, e:
+                # Start the auth flow again.
+                redirect_to("/dropbox-auth-start")
+            except CsrfException, e:
+                http_status(403)
+            except NotApprovedException, e:
+                flash('Not approved?  Why not?')
+                return redirect_to("/home")
+            except ProviderException, e:
+                logger.log("Auth error: %s" % (e,))
+                http_status(403)
+
+    """
+
+    def __init__(self, consumer_key, consumer_secret, redirect_uri, session,
+                 csrf_token_session_key, locale=None):
+        """
+        Construct an instance.
+
+        :param str consumer_key: Your API app's "app key".
+        :param str consumer_secret: Your API app's "app secret".
+        :param str redirect_uri: The URI that the Dropbox server will redirect
+            the user to after the user finishes authorizing your app.  This URI
+            must be HTTPS-based and pre-registered with the Dropbox servers,
+            though localhost URIs are allowed without pre-registration and can
+            be either HTTP or HTTPS.
+        :param dict session: A dict-like object that represents the current
+            user's web session (will be used to save the CSRF token).
+        :param str csrf_token_session_key: The key to use when storing the CSRF
+            token in the session (for example: "dropbox-auth-csrf-token").
+        :param str locale: The locale of the user of your application.  For
+            example "en" or "en_US". Some API calls return localized data and
+            error messages; this setting tells the server which locale to use.
+            By default, the server uses "en_US".
+        """
+        super(DropboxOAuth2Flow, self).__init__(consumer_key, consumer_secret, locale)
+        self.redirect_uri = redirect_uri
+        self.session = session
+        self.csrf_token_session_key = csrf_token_session_key
+
+    def start(self, url_state=None):
+        """
+        Starts the OAuth 2 authorization process.
+
+        This function builds an "authorization URL".  You should redirect your
+        user's browser to this URL, which will give them an opportunity to
+        grant your app access to their Dropbox account.  When the user
+        completes this process, they will be automatically redirected to the
+        ``redirect_uri`` you passed in to the constructor.
+
+        This function will also save a CSRF token to
+        ``session[csrf_token_session_key]`` (as provided to the constructor).
+        This CSRF token will be checked on :meth:`finish()` to prevent request
+        forgery.
+
+        :param str url_state: Any data that you would like to keep in the URL
+            through the authorization process.  This exact value will be
+            returned to you by :meth:`finish()`.
+        :return: The URL for a page on Dropbox's website.  This page will let
+            the user "approve" your app, which gives your app permission to
+            access the user's Dropbox account. Tell the user to visit this URL
+            and approve your app.
+        """
+        csrf_token = base64.urlsafe_b64encode(os.urandom(16)).decode('ascii')
+        state = csrf_token
+        if url_state is not None:
+            state += "|" + url_state
+        self.session[self.csrf_token_session_key] = csrf_token
+
+        return self._get_authorize_url(self.redirect_uri, state)
+
+    def finish(self, query_params):
+        """
+        Call this after the user has visited the authorize URL (see
+        :meth:`start()`), approved your app and was redirected to your redirect
+        URI.
+
+        :param dict query_params: The query parameters on the GET request to
+            your redirect URI.
+        :rtype: OAuth2FlowResult
+        :raises: :class:`BadRequestException` If the redirect URL was missing
+            parameters or if the given parameters were not valid.
+        :raises: :class:`BadStateException` If there's no CSRF token in the
+            session.
+        :raises: :class:`CsrfException` If the ``state`` query parameter
+            doesn't contain the CSRF token from the user's session.
+        :raises: :class:`NotApprovedException` If the user chose not to
+            approve your app.
+        :raises: :class:`ProviderException` If Dropbox redirected to your
+            redirect URI with some unexpected error identifier and error message.
+        """
+        # Check well-formedness of request.
+
+        state = query_params.get('state')
+        if state is None:
+            raise BadRequestException("Missing query parameter 'state'.")
+
+        error = query_params.get('error')
+        error_description = query_params.get('error_description')
+        code = query_params.get('code')
+
+        if error is not None and code is not None:
+            raise BadRequestException(
+                "Query parameters 'code' and 'error' are both set; "
+                "only one must be set.")
+        if error is None and code is None:
+            raise BadRequestException(
+                "Neither query parameter 'code' or 'error' is set.")
+
+        # Check CSRF token
+
+        if self.csrf_token_session_key not in self.session:
+            raise BadStateException('Missing CSRF token in session.')
+        csrf_token_from_session = self.session[self.csrf_token_session_key]
+        if len(csrf_token_from_session) <= 20:
+            raise AssertionError('CSRF token unexpectedly short: %r' %
+                                 csrf_token_from_session)
+
+        split_pos = state.find('|')
+        if split_pos < 0:
+            given_csrf_token = state
+            url_state = None
+        else:
+            given_csrf_token = state[0:split_pos]
+            url_state = state[split_pos + 1:]
+
+        if not _safe_equals(csrf_token_from_session, given_csrf_token):
+            raise CsrfException('expected %r, got %r' %
+                                (csrf_token_from_session, given_csrf_token))
+
+        del self.session[self.csrf_token_session_key]
+
+        # Check for error identifier
+
+        if error is not None:
+            if error == 'access_denied':
+                # The user clicked "Deny"
+                if error_description is None:
+                    raise NotApprovedException(
+                        'No additional description from Dropbox')
+                else:
+                    raise NotApprovedException(
+                        'Additional description from Dropbox: %s' %
+                        error_description)
+            else:
+                # All other errors
+                full_message = error
+                if error_description is not None:
+                    full_message += ": " + error_description
+                raise ProviderException(full_message)
+
+        # If everything went ok, make the network call to get an access token.
+
+        no_redirect_result = self._finish(code, self.redirect_uri)
+        return OAuth2FlowResult.from_no_redirect_result(
+            no_redirect_result, url_state)
+
+
+class BadRequestException(Exception):
+    """
+    Thrown if the redirect URL was missing parameters or if the
+    given parameters were not valid.
+
+    The recommended action is to show an HTTP 400 error page.
+    """
+    pass
+
+
+class BadStateException(Exception):
+    """
+    Thrown if all the parameters are correct, but there's no CSRF token in the
+    session. This probably means that the session expired.
+
+    The recommended action is to redirect the user's browser to try the
+    approval process again.
+    """
+    pass
+
+
+class CsrfException(Exception):
+    """
+    Thrown if the given 'state' parameter doesn't contain the CSRF token from
+    the user's session. This is blocked to prevent CSRF attacks.
+
+    The recommended action is to respond with an HTTP 403 error page.
+    """
+    pass
+
+
+class NotApprovedException(Exception):
+    """
+    The user chose not to approve your app.
+    """
+    pass
+
+
+class ProviderException(Exception):
+    """
+    Dropbox redirected to your redirect URI with some unexpected error
+    identifier and error message.
+
+    The recommended action is to log the error, tell the user something went
+    wrong, and let them try again.
+    """
+    pass
+
+
+def _safe_equals(a, b):
+    if len(a) != len(b):
+        return False
+    res = 0
+    for ca, cb in zip(a, b):
+        res |= ord(ca) ^ ord(cb)
+    return res == 0
+
+
+def _params_to_urlencoded(params):
+    """
+    Returns a application/x-www-form-urlencoded ``str`` representing the
+    key/value pairs in ``params``.
+
+    Keys are values are ``str()``'d before calling ``urllib.urlencode``, with
+    the exception of unicode objects which are utf8-encoded.
+    """
+    def encode(o):
+        if isinstance(o, six.binary_type):
+            return o
+        else:
+            if isinstance(o, six.text_type):
+                return o.encode('utf-8')
+            else:
+                return str(o).encode('utf-8')
+
+    utf8_params = {encode(k): encode(v) for k, v in six.iteritems(params)}
+    return url_encode(utf8_params)

resources/lib/dropbox/properties.py

@@ -0,0 +1,835 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+"""
+This namespace contains helper entities for property and property/template endpoints.
+"""
+
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+class GetPropertyTemplateArg(object):
+    """
+    :ivar template_id: An identifier for property template added by route
+        properties/template/add.
+    """
+
+    __slots__ = [
+        '_template_id_value',
+        '_template_id_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 template_id=None):
+        self._template_id_value = None
+        self._template_id_present = False
+        if template_id is not None:
+            self.template_id = template_id
+
+    @property
+    def template_id(self):
+        """
+        An identifier for property template added by route
+        properties/template/add.
+
+        :rtype: str
+        """
+        if self._template_id_present:
+            return self._template_id_value
+        else:
+            raise AttributeError("missing required field 'template_id'")
+
+    @template_id.setter
+    def template_id(self, val):
+        val = self._template_id_validator.validate(val)
+        self._template_id_value = val
+        self._template_id_present = True
+
+    @template_id.deleter
+    def template_id(self):
+        self._template_id_value = None
+        self._template_id_present = False
+
+    def __repr__(self):
+        return 'GetPropertyTemplateArg(template_id={!r})'.format(
+            self._template_id_value,
+        )
+
+GetPropertyTemplateArg_validator = bv.Struct(GetPropertyTemplateArg)
+
+class PropertyGroupTemplate(object):
+    """
+    Describes property templates that can be filled and associated with a file.
+
+    :ivar name: A display name for the property template. Property template
+        names can be up to 256 bytes.
+    :ivar description: Description for new property template. Property template
+        descriptions can be up to 1024 bytes.
+    :ivar fields: This is a list of custom properties associated with a property
+        template. There can be up to 64 properties in a single property
+        template.
+    """
+
+    __slots__ = [
+        '_name_value',
+        '_name_present',
+        '_description_value',
+        '_description_present',
+        '_fields_value',
+        '_fields_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 name=None,
+                 description=None,
+                 fields=None):
+        self._name_value = None
+        self._name_present = False
+        self._description_value = None
+        self._description_present = False
+        self._fields_value = None
+        self._fields_present = False
+        if name is not None:
+            self.name = name
+        if description is not None:
+            self.description = description
+        if fields is not None:
+            self.fields = fields
+
+    @property
+    def name(self):
+        """
+        A display name for the property template. Property template names can be
+        up to 256 bytes.
+
+        :rtype: str
+        """
+        if self._name_present:
+            return self._name_value
+        else:
+            raise AttributeError("missing required field 'name'")
+
+    @name.setter
+    def name(self, val):
+        val = self._name_validator.validate(val)
+        self._name_value = val
+        self._name_present = True
+
+    @name.deleter
+    def name(self):
+        self._name_value = None
+        self._name_present = False
+
+    @property
+    def description(self):
+        """
+        Description for new property template. Property template descriptions
+        can be up to 1024 bytes.
+
+        :rtype: str
+        """
+        if self._description_present:
+            return self._description_value
+        else:
+            raise AttributeError("missing required field 'description'")
+
+    @description.setter
+    def description(self, val):
+        val = self._description_validator.validate(val)
+        self._description_value = val
+        self._description_present = True
+
+    @description.deleter
+    def description(self):
+        self._description_value = None
+        self._description_present = False
+
+    @property
+    def fields(self):
+        """
+        This is a list of custom properties associated with a property template.
+        There can be up to 64 properties in a single property template.
+
+        :rtype: list of [PropertyFieldTemplate]
+        """
+        if self._fields_present:
+            return self._fields_value
+        else:
+            raise AttributeError("missing required field 'fields'")
+
+    @fields.setter
+    def fields(self, val):
+        val = self._fields_validator.validate(val)
+        self._fields_value = val
+        self._fields_present = True
+
+    @fields.deleter
+    def fields(self):
+        self._fields_value = None
+        self._fields_present = False
+
+    def __repr__(self):
+        return 'PropertyGroupTemplate(name={!r}, description={!r}, fields={!r})'.format(
+            self._name_value,
+            self._description_value,
+            self._fields_value,
+        )
+
+PropertyGroupTemplate_validator = bv.Struct(PropertyGroupTemplate)
+
+class GetPropertyTemplateResult(PropertyGroupTemplate):
+    """
+    The Property template for the specified template.
+    """
+
+    __slots__ = [
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 name=None,
+                 description=None,
+                 fields=None):
+        super(GetPropertyTemplateResult, self).__init__(name,
+                                                        description,
+                                                        fields)
+
+    def __repr__(self):
+        return 'GetPropertyTemplateResult(name={!r}, description={!r}, fields={!r})'.format(
+            self._name_value,
+            self._description_value,
+            self._fields_value,
+        )
+
+GetPropertyTemplateResult_validator = bv.Struct(GetPropertyTemplateResult)
+
+class ListPropertyTemplateIds(object):
+    """
+    :ivar template_ids: List of identifiers for templates added by route
+        properties/template/add.
+    """
+
+    __slots__ = [
+        '_template_ids_value',
+        '_template_ids_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 template_ids=None):
+        self._template_ids_value = None
+        self._template_ids_present = False
+        if template_ids is not None:
+            self.template_ids = template_ids
+
+    @property
+    def template_ids(self):
+        """
+        List of identifiers for templates added by route
+        properties/template/add.
+
+        :rtype: list of [str]
+        """
+        if self._template_ids_present:
+            return self._template_ids_value
+        else:
+            raise AttributeError("missing required field 'template_ids'")
+
+    @template_ids.setter
+    def template_ids(self, val):
+        val = self._template_ids_validator.validate(val)
+        self._template_ids_value = val
+        self._template_ids_present = True
+
+    @template_ids.deleter
+    def template_ids(self):
+        self._template_ids_value = None
+        self._template_ids_present = False
+
+    def __repr__(self):
+        return 'ListPropertyTemplateIds(template_ids={!r})'.format(
+            self._template_ids_value,
+        )
+
+ListPropertyTemplateIds_validator = bv.Struct(ListPropertyTemplateIds)
+
+class PropertyTemplateError(bb.Union):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar str template_not_found: Property template does not exist for given
+        identifier.
+    :ivar restricted_content: You do not have the permissions to modify this
+        property template.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    restricted_content = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    @classmethod
+    def template_not_found(cls, val):
+        """
+        Create an instance of this class set to the ``template_not_found`` tag
+        with value ``val``.
+
+        :param str val:
+        :rtype: PropertyTemplateError
+        """
+        return cls('template_not_found', val)
+
+    def is_template_not_found(self):
+        """
+        Check if the union tag is ``template_not_found``.
+
+        :rtype: bool
+        """
+        return self._tag == 'template_not_found'
+
+    def is_restricted_content(self):
+        """
+        Check if the union tag is ``restricted_content``.
+
+        :rtype: bool
+        """
+        return self._tag == 'restricted_content'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def get_template_not_found(self):
+        """
+        Property template does not exist for given identifier.
+
+        Only call this if :meth:`is_template_not_found` is true.
+
+        :rtype: str
+        """
+        if not self.is_template_not_found():
+            raise AttributeError("tag 'template_not_found' not set")
+        return self._value
+
+    def __repr__(self):
+        return 'PropertyTemplateError(%r, %r)' % (self._tag, self._value)
+
+PropertyTemplateError_validator = bv.Union(PropertyTemplateError)
+
+class ModifyPropertyTemplateError(PropertyTemplateError):
+    """
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar conflicting_property_names: A property field name already exists in
+        the template.
+    :ivar too_many_properties: There are too many properties in the changed
+        template. The maximum number of properties per template is 32.
+    :ivar too_many_templates: There are too many templates for the team.
+    :ivar template_attribute_too_large: The template name, description or field
+        names is too large.
+    """
+
+    # Attribute is overwritten below the class definition
+    conflicting_property_names = None
+    # Attribute is overwritten below the class definition
+    too_many_properties = None
+    # Attribute is overwritten below the class definition
+    too_many_templates = None
+    # Attribute is overwritten below the class definition
+    template_attribute_too_large = None
+
+    def is_conflicting_property_names(self):
+        """
+        Check if the union tag is ``conflicting_property_names``.
+
+        :rtype: bool
+        """
+        return self._tag == 'conflicting_property_names'
+
+    def is_too_many_properties(self):
+        """
+        Check if the union tag is ``too_many_properties``.
+
+        :rtype: bool
+        """
+        return self._tag == 'too_many_properties'
+
+    def is_too_many_templates(self):
+        """
+        Check if the union tag is ``too_many_templates``.
+
+        :rtype: bool
+        """
+        return self._tag == 'too_many_templates'
+
+    def is_template_attribute_too_large(self):
+        """
+        Check if the union tag is ``template_attribute_too_large``.
+
+        :rtype: bool
+        """
+        return self._tag == 'template_attribute_too_large'
+
+    def __repr__(self):
+        return 'ModifyPropertyTemplateError(%r, %r)' % (self._tag, self._value)
+
+ModifyPropertyTemplateError_validator = bv.Union(ModifyPropertyTemplateError)
+
+class PropertyField(object):
+    """
+    :ivar name: This is the name or key of a custom property in a property
+        template. File property names can be up to 256 bytes.
+    :ivar value: Value of a custom property attached to a file. Values can be up
+        to 1024 bytes.
+    """
+
+    __slots__ = [
+        '_name_value',
+        '_name_present',
+        '_value_value',
+        '_value_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 name=None,
+                 value=None):
+        self._name_value = None
+        self._name_present = False
+        self._value_value = None
+        self._value_present = False
+        if name is not None:
+            self.name = name
+        if value is not None:
+            self.value = value
+
+    @property
+    def name(self):
+        """
+        This is the name or key of a custom property in a property template.
+        File property names can be up to 256 bytes.
+
+        :rtype: str
+        """
+        if self._name_present:
+            return self._name_value
+        else:
+            raise AttributeError("missing required field 'name'")
+
+    @name.setter
+    def name(self, val):
+        val = self._name_validator.validate(val)
+        self._name_value = val
+        self._name_present = True
+
+    @name.deleter
+    def name(self):
+        self._name_value = None
+        self._name_present = False
+
+    @property
+    def value(self):
+        """
+        Value of a custom property attached to a file. Values can be up to 1024
+        bytes.
+
+        :rtype: str
+        """
+        if self._value_present:
+            return self._value_value
+        else:
+            raise AttributeError("missing required field 'value'")
+
+    @value.setter
+    def value(self, val):
+        val = self._value_validator.validate(val)
+        self._value_value = val
+        self._value_present = True
+
+    @value.deleter
+    def value(self):
+        self._value_value = None
+        self._value_present = False
+
+    def __repr__(self):
+        return 'PropertyField(name={!r}, value={!r})'.format(
+            self._name_value,
+            self._value_value,
+        )
+
+PropertyField_validator = bv.Struct(PropertyField)
+
+class PropertyFieldTemplate(object):
+    """
+    Describe a single property field type which that can be part of a property
+    template.
+
+    :ivar name: This is the name or key of a custom property in a property
+        template. File property names can be up to 256 bytes.
+    :ivar description: This is the description for a custom property in a
+        property template. File property description can be up to 1024 bytes.
+    :ivar type: This is the data type of the value of this property. This type
+        will be enforced upon property creation and modifications.
+    """
+
+    __slots__ = [
+        '_name_value',
+        '_name_present',
+        '_description_value',
+        '_description_present',
+        '_type_value',
+        '_type_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 name=None,
+                 description=None,
+                 type=None):
+        self._name_value = None
+        self._name_present = False
+        self._description_value = None
+        self._description_present = False
+        self._type_value = None
+        self._type_present = False
+        if name is not None:
+            self.name = name
+        if description is not None:
+            self.description = description
+        if type is not None:
+            self.type = type
+
+    @property
+    def name(self):
+        """
+        This is the name or key of a custom property in a property template.
+        File property names can be up to 256 bytes.
+
+        :rtype: str
+        """
+        if self._name_present:
+            return self._name_value
+        else:
+            raise AttributeError("missing required field 'name'")
+
+    @name.setter
+    def name(self, val):
+        val = self._name_validator.validate(val)
+        self._name_value = val
+        self._name_present = True
+
+    @name.deleter
+    def name(self):
+        self._name_value = None
+        self._name_present = False
+
+    @property
+    def description(self):
+        """
+        This is the description for a custom property in a property template.
+        File property description can be up to 1024 bytes.
+
+        :rtype: str
+        """
+        if self._description_present:
+            return self._description_value
+        else:
+            raise AttributeError("missing required field 'description'")
+
+    @description.setter
+    def description(self, val):
+        val = self._description_validator.validate(val)
+        self._description_value = val
+        self._description_present = True
+
+    @description.deleter
+    def description(self):
+        self._description_value = None
+        self._description_present = False
+
+    @property
+    def type(self):
+        """
+        This is the data type of the value of this property. This type will be
+        enforced upon property creation and modifications.
+
+        :rtype: PropertyType
+        """
+        if self._type_present:
+            return self._type_value
+        else:
+            raise AttributeError("missing required field 'type'")
+
+    @type.setter
+    def type(self, val):
+        self._type_validator.validate_type_only(val)
+        self._type_value = val
+        self._type_present = True
+
+    @type.deleter
+    def type(self):
+        self._type_value = None
+        self._type_present = False
+
+    def __repr__(self):
+        return 'PropertyFieldTemplate(name={!r}, description={!r}, type={!r})'.format(
+            self._name_value,
+            self._description_value,
+            self._type_value,
+        )
+
+PropertyFieldTemplate_validator = bv.Struct(PropertyFieldTemplate)
+
+class PropertyGroup(object):
+    """
+    Collection of custom properties in filled property templates.
+
+    :ivar template_id: A unique identifier for a property template type.
+    :ivar fields: This is a list of custom properties associated with a file.
+        There can be up to 32 properties for a template.
+    """
+
+    __slots__ = [
+        '_template_id_value',
+        '_template_id_present',
+        '_fields_value',
+        '_fields_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 template_id=None,
+                 fields=None):
+        self._template_id_value = None
+        self._template_id_present = False
+        self._fields_value = None
+        self._fields_present = False
+        if template_id is not None:
+            self.template_id = template_id
+        if fields is not None:
+            self.fields = fields
+
+    @property
+    def template_id(self):
+        """
+        A unique identifier for a property template type.
+
+        :rtype: str
+        """
+        if self._template_id_present:
+            return self._template_id_value
+        else:
+            raise AttributeError("missing required field 'template_id'")
+
+    @template_id.setter
+    def template_id(self, val):
+        val = self._template_id_validator.validate(val)
+        self._template_id_value = val
+        self._template_id_present = True
+
+    @template_id.deleter
+    def template_id(self):
+        self._template_id_value = None
+        self._template_id_present = False
+
+    @property
+    def fields(self):
+        """
+        This is a list of custom properties associated with a file. There can be
+        up to 32 properties for a template.
+
+        :rtype: list of [PropertyField]
+        """
+        if self._fields_present:
+            return self._fields_value
+        else:
+            raise AttributeError("missing required field 'fields'")
+
+    @fields.setter
+    def fields(self, val):
+        val = self._fields_validator.validate(val)
+        self._fields_value = val
+        self._fields_present = True
+
+    @fields.deleter
+    def fields(self):
+        self._fields_value = None
+        self._fields_present = False
+
+    def __repr__(self):
+        return 'PropertyGroup(template_id={!r}, fields={!r})'.format(
+            self._template_id_value,
+            self._fields_value,
+        )
+
+PropertyGroup_validator = bv.Struct(PropertyGroup)
+
+class PropertyType(bb.Union):
+    """
+    Data type of the given property added. This endpoint is in beta and  only
+    properties of type strings is supported.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar string: The associated property will be of type string. Unicode is
+        supported.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    string = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_string(self):
+        """
+        Check if the union tag is ``string``.
+
+        :rtype: bool
+        """
+        return self._tag == 'string'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'PropertyType(%r, %r)' % (self._tag, self._value)
+
+PropertyType_validator = bv.Union(PropertyType)
+
+TemplateId_validator = bv.String(min_length=1, pattern=u'(/|ptid:).*')
+GetPropertyTemplateArg._template_id_validator = TemplateId_validator
+GetPropertyTemplateArg._all_field_names_ = set(['template_id'])
+GetPropertyTemplateArg._all_fields_ = [('template_id', GetPropertyTemplateArg._template_id_validator)]
+
+PropertyGroupTemplate._name_validator = bv.String()
+PropertyGroupTemplate._description_validator = bv.String()
+PropertyGroupTemplate._fields_validator = bv.List(PropertyFieldTemplate_validator)
+PropertyGroupTemplate._all_field_names_ = set([
+    'name',
+    'description',
+    'fields',
+])
+PropertyGroupTemplate._all_fields_ = [
+    ('name', PropertyGroupTemplate._name_validator),
+    ('description', PropertyGroupTemplate._description_validator),
+    ('fields', PropertyGroupTemplate._fields_validator),
+]
+
+GetPropertyTemplateResult._all_field_names_ = PropertyGroupTemplate._all_field_names_.union(set([]))
+GetPropertyTemplateResult._all_fields_ = PropertyGroupTemplate._all_fields_ + []
+
+ListPropertyTemplateIds._template_ids_validator = bv.List(TemplateId_validator)
+ListPropertyTemplateIds._all_field_names_ = set(['template_ids'])
+ListPropertyTemplateIds._all_fields_ = [('template_ids', ListPropertyTemplateIds._template_ids_validator)]
+
+PropertyTemplateError._template_not_found_validator = TemplateId_validator
+PropertyTemplateError._restricted_content_validator = bv.Void()
+PropertyTemplateError._other_validator = bv.Void()
+PropertyTemplateError._tagmap = {
+    'template_not_found': PropertyTemplateError._template_not_found_validator,
+    'restricted_content': PropertyTemplateError._restricted_content_validator,
+    'other': PropertyTemplateError._other_validator,
+}
+
+PropertyTemplateError.restricted_content = PropertyTemplateError('restricted_content')
+PropertyTemplateError.other = PropertyTemplateError('other')
+
+ModifyPropertyTemplateError._conflicting_property_names_validator = bv.Void()
+ModifyPropertyTemplateError._too_many_properties_validator = bv.Void()
+ModifyPropertyTemplateError._too_many_templates_validator = bv.Void()
+ModifyPropertyTemplateError._template_attribute_too_large_validator = bv.Void()
+ModifyPropertyTemplateError._tagmap = {
+    'conflicting_property_names': ModifyPropertyTemplateError._conflicting_property_names_validator,
+    'too_many_properties': ModifyPropertyTemplateError._too_many_properties_validator,
+    'too_many_templates': ModifyPropertyTemplateError._too_many_templates_validator,
+    'template_attribute_too_large': ModifyPropertyTemplateError._template_attribute_too_large_validator,
+}
+ModifyPropertyTemplateError._tagmap.update(PropertyTemplateError._tagmap)
+
+ModifyPropertyTemplateError.conflicting_property_names = ModifyPropertyTemplateError('conflicting_property_names')
+ModifyPropertyTemplateError.too_many_properties = ModifyPropertyTemplateError('too_many_properties')
+ModifyPropertyTemplateError.too_many_templates = ModifyPropertyTemplateError('too_many_templates')
+ModifyPropertyTemplateError.template_attribute_too_large = ModifyPropertyTemplateError('template_attribute_too_large')
+
+PropertyField._name_validator = bv.String()
+PropertyField._value_validator = bv.String()
+PropertyField._all_field_names_ = set([
+    'name',
+    'value',
+])
+PropertyField._all_fields_ = [
+    ('name', PropertyField._name_validator),
+    ('value', PropertyField._value_validator),
+]
+
+PropertyFieldTemplate._name_validator = bv.String()
+PropertyFieldTemplate._description_validator = bv.String()
+PropertyFieldTemplate._type_validator = PropertyType_validator
+PropertyFieldTemplate._all_field_names_ = set([
+    'name',
+    'description',
+    'type',
+])
+PropertyFieldTemplate._all_fields_ = [
+    ('name', PropertyFieldTemplate._name_validator),
+    ('description', PropertyFieldTemplate._description_validator),
+    ('type', PropertyFieldTemplate._type_validator),
+]
+
+PropertyGroup._template_id_validator = TemplateId_validator
+PropertyGroup._fields_validator = bv.List(PropertyField_validator)
+PropertyGroup._all_field_names_ = set([
+    'template_id',
+    'fields',
+])
+PropertyGroup._all_fields_ = [
+    ('template_id', PropertyGroup._template_id_validator),
+    ('fields', PropertyGroup._fields_validator),
+]
+
+PropertyType._string_validator = bv.Void()
+PropertyType._other_validator = bv.Void()
+PropertyType._tagmap = {
+    'string': PropertyType._string_validator,
+    'other': PropertyType._other_validator,
+}
+
+PropertyType.string = PropertyType('string')
+PropertyType.other = PropertyType('other')
+
+ROUTES = {
+}
+

resources/lib/dropbox/rest.py

@@ -1,419 +0,0 @@
-"""
-A simple JSON REST request abstraction layer that is used by the
-``dropbox.client`` and ``dropbox.session`` modules. You shouldn't need to use this.
-"""
-
-import io
-import socket
-import ssl
-import sys
-import urllib
-import pkg_resources
-
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
-try:
-   import requests.packages.urllib3 as urllib3
-except ImportError:
-    raise ImportError('Dropbox python client requires urllib3.')
-
-
-SDK_VERSION = "2.2.0"
-
-TRUSTED_CERT_FILE = pkg_resources.resource_filename(__name__, 'trusted-certs.crt')
-
-
-class RESTResponse(io.IOBase):
-    """
-    Responses to requests can come in the form of ``RESTResponse``. These are
-    thin wrappers around the socket file descriptor.
-    :meth:`read()` and :meth:`close()` are implemented.
-    It is important to call :meth:`close()` to return the connection
-    back to the connection pool to be reused. If a connection
-    is not closed by the caller it may leak memory. The object makes a
-    best-effort attempt upon destruction to call :meth:`close()`,
-    but it's still best to explicitly call :meth:`close()`.
-    """
-
-    def __init__(self, resp):
-        # arg: A urllib3.HTTPResponse object
-        self.urllib3_response = resp
-        self.status = resp.status
-        self.version = resp.version
-        self.reason = resp.reason
-        self.strict = resp.strict
-        self.is_closed = False
-
-    def __del__(self):
-        # Attempt to close when ref-count goes to zero.
-        self.close()
-
-    def __exit__(self, typ, value, traceback):
-        # Allow this to be used in "with" blocks.
-        self.close()
-
-    # -----------------
-    # Important methods
-    # -----------------
-    def read(self, amt=None):
-        """
-        Read data off the underlying socket.
-
-        Parameters
-            amt
-              Amount of data to read. Defaults to ``None``, indicating to read
-              everything.
-
-        Returns
-              Data off the socket. If ``amt`` is not ``None``, at most ``amt`` bytes are returned.
-              An empty string when the socket has no data.
-
-        Raises
-            ``ValueError``
-              If the ``RESTResponse`` has already been closed.
-        """
-        if self.is_closed:
-            raise ValueError('Response already closed')
-        return self.urllib3_response.read(amt)
-
-    BLOCKSIZE = 4 * 1024 * 1024 # 4MB at a time just because
-
-    def close(self):
-        """Closes the underlying socket."""
-
-        # Double closing is harmless
-        if self.is_closed:
-            return
-
-        # Read any remaining crap off the socket before releasing the
-        # connection. Buffer it just in case it's huge
-        while self.read(RESTResponse.BLOCKSIZE):
-            pass
-
-        # Mark as closed and release the connection (exactly once)
-        self.is_closed = True
-        self.urllib3_response.release_conn()
-
-    @property
-    def closed(self):
-        return self.is_closed
-
-
-    # ---------------------------------
-    # Backwards compat for HTTPResponse
-    # ---------------------------------
-    def getheaders(self):
-        """Returns a dictionary of the response headers."""
-        return self.urllib3_response.getheaders()
-
-    def getheader(self, name, default=None):
-        """Returns a given response header."""
-        return self.urllib3_response.getheader(name, default)
-
-    # Some compat functions showed up recently in urllib3
-    try:
-        urllib3.HTTPResponse.flush
-        urllib3.HTTPResponse.fileno
-        def fileno(self):
-            return self.urllib3_response.fileno()
-        def flush(self):
-            return self.urllib3_response.flush()
-    except AttributeError:
-        pass
-
-def create_connection(address):
-    host, port = address
-    err = None
-    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
-        af, socktype, proto, canonname, sa = res
-        sock = None
-        try:
-            sock = socket.socket(af, socktype, proto)
-            sock.connect(sa)
-            return sock
-
-        except socket.error as e:
-            err = e
-            if sock is not None:
-                sock.close()
-
-    if err is not None:
-        raise err
-    else:
-        raise socket.error("getaddrinfo returns an empty list")
-
-def json_loadb(data):
-    if sys.version_info >= (3,):
-        data = data.decode('utf8')
-    return json.loads(data)
-
-
-class RESTClientObject(object):
-    def __init__(self, max_reusable_connections=8, mock_urlopen=None):
-        """
-        Parameters
-            max_reusable_connections
-                max connections to keep alive in the pool
-            mock_urlopen
-                an optional alternate urlopen function for testing
-
-        This class uses ``urllib3`` to maintain a pool of connections. We attempt
-        to grab an existing idle connection from the pool, otherwise we spin
-        up a new connection. Once a connection is closed, it is reinserted
-        into the pool (unless the pool is full).
-
-        SSL settings:
-        - Certificates validated using Dropbox-approved trusted root certs
-        - TLS v1.0 (newer TLS versions are not supported by urllib3)
-        - Default ciphersuites. Choosing ciphersuites is not supported by urllib3
-        - Hostname verification is provided by urllib3
-        """
-        self.mock_urlopen = mock_urlopen
-        self.pool_manager = urllib3.PoolManager(
-            num_pools=4, # only a handful of hosts. api.dropbox.com, api-content.dropbox.com
-            maxsize=max_reusable_connections,
-            block=False,
-            timeout=60.0, # long enough so datastores await doesn't get interrupted
-            cert_reqs=ssl.CERT_REQUIRED,
-            ca_certs=TRUSTED_CERT_FILE,
-            ssl_version=ssl.PROTOCOL_TLSv1,
-        )
-
-    def request(self, method, url, post_params=None, body=None, headers=None, raw_response=False):
-        """Performs a REST request. See :meth:`RESTClient.request()` for detailed description."""
-
-        post_params = post_params or {}
-        headers = headers or {}
-        headers['User-Agent'] = 'OfficialDropboxPythonSDK/' + SDK_VERSION
-
-        if post_params:
-            if body:
-                raise ValueError("body parameter cannot be used with post_params parameter")
-            body = params_to_urlencoded(post_params)
-            headers["Content-type"] = "application/x-www-form-urlencoded"
-
-        # Handle StringIO instances, because urllib3 doesn't.
-        if hasattr(body, 'getvalue'):
-            body = str(body.getvalue())
-            headers["Content-Length"] = len(body)
-
-        # Reject any headers containing newlines; the error from the server isn't pretty.
-        for key, value in headers.items():
-            if isinstance(value, basestring) and '\n' in value:
-                raise ValueError("headers should not contain newlines (%s: %s)" %
-                                 (key, value))
-
-        try:
-            # Grab a connection from the pool to make the request.
-            # We return it to the pool when caller close() the response
-            urlopen = self.mock_urlopen if self.mock_urlopen else self.pool_manager.urlopen
-            r = urlopen(
-                method=method,
-                url=url,
-                body=body,
-                headers=headers,
-                preload_content=False
-            )
-            r = RESTResponse(r) # wrap up the urllib3 response before proceeding
-        except socket.error as e:
-            raise RESTSocketError(url, e)
-        except urllib3.exceptions.SSLError as e:
-            raise RESTSocketError(url, "SSL certificate error: %s" % e)
-
-        if r.status not in (200, 206):
-            raise ErrorResponse(r, r.read())
-
-        return self.process_response(r, raw_response)
-
-    def process_response(self, r, raw_response):
-        if raw_response:
-            return r
-        else:
-            s = r.read()
-            try:
-                resp = json_loadb(s)
-            except ValueError:
-                raise ErrorResponse(r, s)
-            r.close()
-
-        return resp
-
-    def GET(self, url, headers=None, raw_response=False):
-        assert type(raw_response) == bool
-        return self.request("GET", url, headers=headers, raw_response=raw_response)
-
-    def POST(self, url, params=None, headers=None, raw_response=False):
-        assert type(raw_response) == bool
-        if params is None:
-            params = {}
-
-        return self.request("POST", url,
-                            post_params=params, headers=headers, raw_response=raw_response)
-
-    def PUT(self, url, body, headers=None, raw_response=False):
-        assert type(raw_response) == bool
-        return self.request("PUT", url, body=body, headers=headers, raw_response=raw_response)
-
-
-class RESTClient(object):
-    """
-    A class with all static methods to perform JSON REST requests that is used internally
-    by the Dropbox Client API. It provides just enough gear to make requests
-    and get responses as JSON data (when applicable). All requests happen over SSL.
-    """
-
-    IMPL = RESTClientObject()
-
-    @classmethod
-    def request(cls, *n, **kw):
-        """Perform a REST request and parse the response.
-
-        Parameters
-            method
-              An HTTP method (e.g. ``'GET'`` or ``'POST'``).
-            url
-              The URL to make a request to.
-            post_params
-              A dictionary of parameters to put in the body of the request.
-              This option may not be used if the body parameter is given.
-            body
-              The body of the request. Typically, this value will be a string.
-              It may also be a file-like object. The body
-              parameter may not be used with the post_params parameter.
-            headers
-              A dictionary of headers to send with the request.
-            raw_response
-              Whether to return a :class:`RESTResponse` object. Default ``False``.
-              It's best enabled for requests that return large amounts of data that you
-              would want to ``.read()`` incrementally rather than loading into memory. Also
-              use this for calls where you need to read metadata like status or headers,
-              or if the body is not JSON.
-
-        Returns
-              The JSON-decoded data from the server, unless ``raw_response`` is
-              set, in which case a :class:`RESTResponse` object is returned instead.
-
-        Raises
-            :class:`ErrorResponse`
-              The returned HTTP status is not 200, or the body was
-              not parsed from JSON successfully.
-            :class:`RESTSocketError`
-              A ``socket.error`` was raised while contacting Dropbox.
-        """
-        return cls.IMPL.request(*n, **kw)
-
-    @classmethod
-    def GET(cls, *n, **kw):
-        """Perform a GET request using :meth:`RESTClient.request()`."""
-        return cls.IMPL.GET(*n, **kw)
-
-    @classmethod
-    def POST(cls, *n, **kw):
-        """Perform a POST request using :meth:`RESTClient.request()`."""
-        return cls.IMPL.POST(*n, **kw)
-
-    @classmethod
-    def PUT(cls, *n, **kw):
-        """Perform a PUT request using :meth:`RESTClient.request()`."""
-        return cls.IMPL.PUT(*n, **kw)
-
-
-class RESTSocketError(socket.error):
-    """A light wrapper for ``socket.error`` that adds some more information."""
-
-    def __init__(self, host, e):
-        msg = "Error connecting to \"%s\": %s" % (host, str(e))
-        socket.error.__init__(self, msg)
-
-
-# Dummy class for docstrings, see doco.py.
-class _ErrorResponse__doc__(Exception):
-    """Exception raised when :class:`DropboxClient` exeriences a problem.
-
-    For example, this is raised when the server returns an unexpected
-    non-200 HTTP response.
-    """
-
-    _status__doc__ = "HTTP response status (an int)."
-    _reason__doc__ = "HTTP response reason (a string)."
-    _headers__doc__ = "HTTP response headers (a list of (header, value) tuples)."
-    _body__doc__ = "HTTP response body (string or JSON dict)."
-    _error_msg__doc__ = "Error message for developer (optional)."
-    _user_error_msg__doc__ = "Error message for end user (optional)."
-
-
-class ErrorResponse(Exception):
-    """
-    Raised by :meth:`RESTClient.request()` for requests that:
-
-      - Return a non-200 HTTP response, or
-      - Have a non-JSON response body, or
-      - Have a malformed/missing header in the response.
-
-    Most errors that Dropbox returns will have an error field that is unpacked and
-    placed on the ErrorResponse exception. In some situations, a user_error field
-    will also come back. Messages under user_error are worth showing to an end-user
-    of your app, while other errors are likely only useful for you as the developer.
-    """
-
-    def __init__(self, http_resp, body):
-        """
-        Parameters
-            http_resp
-                      The :class:`RESTResponse` which errored
-            body
-                      Body of the :class:`RESTResponse`.
-                      The reason we can't simply call ``http_resp.read()`` to
-                      get the body, is that ``read()`` is not idempotent.
-                      Since it can't be called more than once,
-                      we have to pass the string body in separately
-        """
-        self.status = http_resp.status
-        self.reason = http_resp.reason
-        self.body = body
-        self.headers = http_resp.getheaders()
-        http_resp.close() # won't need this connection anymore
-
-        try:
-            self.body = json_loadb(self.body)
-            self.error_msg = self.body.get('error')
-            self.user_error_msg = self.body.get('user_error')
-        except ValueError:
-            self.error_msg = None
-            self.user_error_msg = None
-
-    def __str__(self):
-        if self.user_error_msg and self.user_error_msg != self.error_msg:
-            # one is translated and the other is English
-            msg = "%r (%r)" % (self.user_error_msg, self.error_msg)
-        elif self.error_msg:
-            msg = repr(self.error_msg)
-        elif not self.body:
-            msg = repr(self.reason)
-        else:
-            msg = "Error parsing response body or headers: " +\
-                  "Body - %.100r Headers - %r" % (self.body, self.headers)
-
-        return "[%d] %s" % (self.status, msg)
-
-
-def params_to_urlencoded(params):
-    """
-    Returns a application/x-www-form-urlencoded 'str' representing the key/value pairs in 'params'.
-    
-    Keys are values are str()'d before calling urllib.urlencode, with the exception of unicode
-    objects which are utf8-encoded.
-    """
-    def encode(o):
-        if isinstance(o, unicode):
-            return o.encode('utf8')
-        else:
-            return str(o)
-    utf8_params={}
-    for k, v in params.iteritems():
-        utf8_params[encode(k)]= encode(v)
-        
-    return urllib.urlencode(utf8_params)

resources/lib/dropbox/session.py

@@ -1,308 +1,51 @@
-"""
-dropbox.session.DropboxSession is responsible for holding OAuth authentication
-info (app key/secret, request key/secret, access key/secret). It knows how to
-use all of this information to craft properly constructed requests to Dropbox.
+import pkg_resources
+import os
+import ssl
 
-A DropboxSession object must be passed to a dropbox.client.DropboxClient object upon
-initialization.
+import requests
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.poolmanager import PoolManager
 
-"""
-from __future__ import absolute_import
+API_DOMAIN = os.environ.get('DROPBOX_API_DOMAIN',
+    os.environ.get('DROPBOX_DOMAIN', '.dropboxapi.com'))
 
-import random
-import sys
-import time
-import urllib
+WEB_DOMAIN = os.environ.get('DROPBOX_WEB_DOMAIN',
+    os.environ.get('DROPBOX_DOMAIN', '.dropbox.com'))
 
-try:
-    from urlparse import parse_qs
-except ImportError:
-    # fall back for Python 2.5
-    from cgi import parse_qs
+# Default short hostname for RPC-style routes.
+HOST_API = 'api'
 
-from . import rest
+# Default short hostname for upload and download-style routes.
+HOST_CONTENT = 'content'
 
-class OAuthToken(object):
-    """
-    A class representing an OAuth token. Contains two fields: ``key`` and
-    ``secret``.
-    """
-    def __init__(self, key, secret):
-        self.key = key
-        self.secret = secret
+# Default short hostname for longpoll routes.
+HOST_NOTIFY = 'notify'
 
-class BaseSession(object):
-    API_VERSION = 1
+# Default short hostname for the Drobox website.
+HOST_WWW = 'www'
 
-    API_HOST = "api.dropbox.com"
-    WEB_HOST = "www.dropbox.com"
-    API_CONTENT_HOST = "api-content.dropbox.com"
-    API_NOTIFICATION_HOST = "api-notify.dropbox.com"
+API_HOST = os.environ.get('DROPBOX_API_HOST', HOST_API + API_DOMAIN)
+API_CONTENT_HOST = os.environ.get('DROPBOX_API_CONTENT_HOST', HOST_CONTENT + API_DOMAIN)
+API_NOTIFICATION_HOST = os.environ.get('DROPBOX_API_NOTIFY_HOST', HOST_NOTIFY + API_DOMAIN)
+WEB_HOST = os.environ.get('DROPBOX_WEB_HOST', HOST_WWW + WEB_DOMAIN)
 
-    def __init__(self, consumer_key, consumer_secret, access_type="auto", locale=None, rest_client=rest.RESTClient):
-        """Initialize a DropboxSession object.
+_TRUSTED_CERT_FILE = pkg_resources.resource_filename(__name__, 'trusted-certs.crt')
 
-        Your consumer key and secret are available
-        at https://www.dropbox.com/developers/apps
+# TODO(kelkabany): We probably only want to instantiate this once so that even
+# if multiple Dropbox objects are instantiated, they all share the same pool.
+class _SSLAdapter(HTTPAdapter):
+    def init_poolmanager(self, connections, maxsize, block=False, **_):
+        self.poolmanager = PoolManager(
+            num_pools=connections,
+            maxsize=maxsize,
+            block=block,
+            cert_reqs=ssl.CERT_REQUIRED,
+            ca_certs=_TRUSTED_CERT_FILE,
+        )
 
-        Args:
+def pinned_session(pool_maxsize=8):
+    http_adapter = _SSLAdapter(pool_connections=4, pool_maxsize=pool_maxsize)
+    _session = requests.session()
+    _session.mount('https://', http_adapter)
 
-            - ``access_type``: Either 'auto' (the default), 'dropbox', or
-                'app_folder'. You probably don't need to specify this and should
-                just use the default.
-            - ``locale``: A locale string ('en', 'pt_PT', etc.) [optional]
-                The locale setting will be used to translate any user-facing error
-                messages that the server generates. At this time Dropbox supports
-                'en', 'es', 'fr', 'de', and 'ja', though we will be supporting more
-                languages in the future. If you send a language the server doesn't
-                support, messages will remain in English. Look for these translated
-                messages in rest.ErrorResponse exceptions as e.user_error_msg.
-
-        """
-        assert access_type in ['dropbox', 'app_folder', 'auto'], "expected access_type of 'dropbox' or 'app_folder'"
-        self.consumer_creds = OAuthToken(consumer_key, consumer_secret)
-        self.token = None
-        self.request_token = None
-        self.root = 'sandbox' if access_type == 'app_folder' else access_type
-        self.locale = locale
-        self.rest_client = rest_client
-
-    def is_linked(self):
-        """Return whether the DropboxSession has an access token attached."""
-        return bool(self.token)
-
-    def unlink(self):
-        """Remove any attached access token from the DropboxSession."""
-        self.token = None
-
-    def build_path(self, target, params=None):
-        """Build the path component for an API URL.
-
-        This method urlencodes the parameters, adds them
-        to the end of the target url, and puts a marker for the API
-        version in front.
-
-        Args:
-            - ``target``: A target url (e.g. '/files') to build upon.
-            - ``params``: A dictionary of parameters (name to value). [optional]
-
-        Returns:
-            - The path and parameters components of an API URL.
-        """
-        if sys.version_info < (3,) and type(target) == unicode:
-            target = target.encode("utf8")
-
-        target_path = urllib.quote(target)
-
-        params = params or {}
-        params = params.copy()
-
-        if self.locale:
-            params['locale'] = self.locale
-
-        if params:
-            return "/%s%s?%s" % (self.API_VERSION, target_path, urllib.urlencode(params))
-        else:
-            return "/%s%s" % (self.API_VERSION, target_path)
-
-    def build_url(self, host, target, params=None):
-        """Build an API URL.
-
-        This method adds scheme and hostname to the path
-        returned from build_path.
-
-        Args:
-            - ``target``: A target url (e.g. '/files') to build upon.
-            - ``params``: A dictionary of parameters (name to value). [optional]
-
-        Returns:
-            - The full API URL.
-        """
-        return "https://%s%s" % (host, self.build_path(target, params))
-
-class DropboxSession(BaseSession):
-
-    def set_token(self, access_token, access_token_secret):
-        """Attach an access token to the DropboxSession.
-
-        Note that the access 'token' is made up of both a token string
-        and a secret string.
-        """
-        self.token = OAuthToken(access_token, access_token_secret)
-
-    def set_request_token(self, request_token, request_token_secret):
-        """Attach an request token to the DropboxSession.
-
-        Note that the request 'token' is made up of both a token string
-        and a secret string.
-        """
-        self.request_token = OAuthToken(request_token, request_token_secret)
-
-    def build_authorize_url(self, request_token, oauth_callback=None):
-        """Build a request token authorization URL.
-
-        After obtaining a request token, you'll need to send the user to
-        the URL returned from this function so that they can confirm that
-        they want to connect their account to your app.
-
-        Args:
-            - ``request_token``: A request token from obtain_request_token.
-            - ``oauth_callback``: A url to redirect back to with the authorized
-              request token.
-
-        Returns:
-            - An authorization for the given request token.
-        """
-        params = {'oauth_token': request_token.key,
-                  }
-
-        if oauth_callback:
-            params['oauth_callback'] = oauth_callback
-
-        return self.build_url(self.WEB_HOST, '/oauth/authorize', params)
-
-    def obtain_request_token(self):
-        """Obtain a request token from the Dropbox API.
-
-        This is your first step in the OAuth process.  You call this to get a
-        request_token from the Dropbox server that you can then use with
-        DropboxSession.build_authorize_url() to get the user to authorize it.
-        After it's authorized you use this token with
-        DropboxSession.obtain_access_token() to get an access token.
-
-        NOTE:  You should only need to do this once for each user, and then you
-        can store the access token for that user for later operations.
-
-        Returns:
-            - An :py:class:`OAuthToken` object representing the
-              request token Dropbox assigned to this app. Also attaches the
-              request token as self.request_token.
-        """
-        self.token = None # clear any token currently on the request
-        url = self.build_url(self.API_HOST, '/oauth/request_token')
-        headers, params = self.build_access_headers('POST', url)
-
-        response = self.rest_client.POST(url, headers=headers, params=params, raw_response=True)
-        self.request_token = self._parse_token(response.read())
-        return self.request_token
-
-    def obtain_access_token(self, request_token=None):
-        """Obtain an access token for a user.
-
-        After you get a request token, and then send the user to the authorize
-        URL, you can use the authorized request token with this method to get the
-        access token to use for future operations. The access token is stored on
-        the session object.
-
-        Args:
-            - ``request_token``: A request token from obtain_request_token. [optional]
-              The request_token should have been authorized via the
-              authorization url from build_authorize_url. If you don't pass
-              a request_token, the fallback is self.request_token, which
-              will exist if you previously called obtain_request_token on this
-              DropboxSession instance.
-
-        Returns:
-            - An :py:class:`OAuthToken` object with fields ``key`` and ``secret``
-              representing the access token Dropbox assigned to this app and
-              user. Also attaches the access token as self.token.
-        """
-        request_token = request_token or self.request_token
-        assert request_token, "No request_token available on the session. Please pass one."
-        url = self.build_url(self.API_HOST, '/oauth/access_token')
-        headers, params = self.build_access_headers('POST', url, request_token=request_token)
-
-        response = self.rest_client.POST(url, headers=headers, params=params, raw_response=True)
-        self.token = self._parse_token(response.read())
-        return self.token
-
-    def build_access_headers(self, method, resource_url, params=None, request_token=None):
-        """Build OAuth access headers for a future request.
-
-        Args:
-            - ``method``: The HTTP method being used (e.g. 'GET' or 'POST').
-            - ``resource_url``: The full url the request will be made to.
-            - ``params``: A dictionary of parameters to add to what's already on the url.
-              Typically, this would consist of POST parameters.
-
-        Returns:
-            - A tuple of (header_dict, params) where header_dict is a dictionary
-              of header names and values appropriate for passing into dropbox.rest.RESTClient
-              and params is a dictionary like the one that was passed in, but augmented with
-              oauth-related parameters as appropriate.
-        """
-        if params is None:
-            params = {}
-        else:
-            params = params.copy()
-
-        oauth_params = {
-            'oauth_consumer_key' : self.consumer_creds.key,
-            'oauth_timestamp' : self._generate_oauth_timestamp(),
-            'oauth_nonce' : self._generate_oauth_nonce(),
-            'oauth_version' : self._oauth_version(),
-        }
-
-        token = request_token if request_token is not None else self.token
-
-        if token:
-            oauth_params['oauth_token'] = token.key
-
-        self._oauth_sign_request(oauth_params, self.consumer_creds, token)
-
-        params.update(oauth_params)
-
-        return {}, params
-
-    @classmethod
-    def _oauth_sign_request(cls, params, consumer_pair, token_pair):
-        params.update({'oauth_signature_method' : 'PLAINTEXT',
-                       'oauth_signature' : ('%s&%s' % (consumer_pair.secret, token_pair.secret)
-                                            if token_pair is not None else
-                                            '%s&' % (consumer_pair.secret,))})
-
-    @classmethod
-    def _generate_oauth_timestamp(cls):
-        return int(time.time())
-
-    @classmethod
-    def _generate_oauth_nonce(cls, length=8):
-        return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-    @classmethod
-    def _oauth_version(cls):
-        return '1.0'
-
-    @classmethod
-    def _parse_token(cls, s):
-        if not s:
-            raise ValueError("Invalid parameter string.")
-
-        params = parse_qs(s, keep_blank_values=False)
-        if not params:
-            raise ValueError("Invalid parameter string: %r" % s)
-
-        try:
-            key = params['oauth_token'][0]
-        except Exception:
-            raise ValueError("'oauth_token' not found in OAuth request.")
-
-        try:
-            secret = params['oauth_token_secret'][0]
-        except Exception:
-            raise ValueError("'oauth_token_secret' not found in "
-                             "OAuth request.")
-
-        return OAuthToken(key, secret)
-
-# Don't use this class directly.
-class DropboxOAuth2Session(BaseSession):
-
-    def __init__(self, oauth2_access_token, locale, rest_client=rest.RESTClient):
-        super(DropboxOAuth2Session, self).__init__("", "", "auto", locale=locale, rest_client=rest_client)
-        self.access_token = oauth2_access_token
-
-    def build_access_headers(self, method, resource_url, params=None, token=None):
-        assert token is None
-        headers = {"Authorization": "Bearer " + self.access_token}
-        return headers, params
+    return _session

resources/lib/dropbox/six.py

@@ -1,11 +0,0 @@
-import sys
-
-def b(str_):
-    if sys.version_info >= (3,):
-        str_ = str_.encode('latin1')
-    return str_
-
-def u(str_):
-    if sys.version_info < (3,):
-        str_ = str_.decode('latin1')
-    return str_

resources/lib/dropbox/stone_base.py

@@ -0,0 +1,75 @@
+"""
+Helpers for representing Stone data types in Python.
+
+This module should be dropped into a project that requires the use of Stone. In
+the future, this could be imported from a pre-installed Python package, rather
+than being added to a project.
+"""
+
+from __future__ import absolute_import, unicode_literals
+
+try:
+    from . import stone_validators as bv
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv  # type: ignore
+
+_MYPY = False
+if _MYPY:
+    import typing  # noqa: F401 # pylint: disable=import-error,unused-import,useless-suppression
+
+
+class Union(object):
+    # TODO(kelkabany): Possible optimization is to remove _value if a
+    # union is composed of only symbols.
+    __slots__ = ['_tag', '_value']
+    _tagmap = {}  # type: typing.Dict[typing.Text, bv.Validator]
+
+    def __init__(self, tag, value=None):
+        # type: (typing.Text, typing.Optional[typing.Any]) -> None
+        assert tag in self._tagmap, 'Invalid tag %r.' % tag
+        validator = self._tagmap[tag]
+        if isinstance(validator, bv.Void):
+            assert value is None, 'Void type union member must have None value.'
+        elif isinstance(validator, (bv.Struct, bv.Union)):
+            validator.validate_type_only(value)
+        else:
+            validator.validate(value)
+        self._tag = tag
+        self._value = value
+
+    def __eq__(self, other):
+        # Also need to check if one class is a subclass of another. If one union extends another,
+        # the common fields should be able to be compared to each other.
+        return (
+            isinstance(other, Union) and
+            (isinstance(self, other.__class__) or isinstance(other, self.__class__)) and
+            self._tag == other._tag and self._value == other._value
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((self._tag, self._value))
+
+class Route(object):
+
+    def __init__(self, name, deprecated, arg_type, result_type, error_type, attrs):
+        self.name = name
+        self.deprecated = deprecated
+        self.arg_type = arg_type
+        self.result_type = result_type
+        self.error_type = error_type
+        assert isinstance(attrs, dict), 'Expected dict, got %r' % attrs
+        self.attrs = attrs
+
+    def __repr__(self):
+        return 'Route({!r}, {!r}, {!r}, {!r}, {!r}, {!r})'.format(
+            self.name,
+            self.deprecated,
+            self.arg_type,
+            self.result_type,
+            self.error_type,
+            self.attrs)

resources/lib/dropbox/stone_validators.py

@@ -0,0 +1,592 @@
+"""
+Defines classes to represent each Stone type in Python. These classes should
+be used to validate Python objects and normalize them for a given type.
+
+The data types defined here should not be specific to an RPC or serialization
+format.
+
+This module should be dropped into a project that requires the use of Stone. In
+the future, this could be imported from a pre-installed Python package, rather
+than being added to a project.
+"""
+
+from __future__ import absolute_import, unicode_literals
+
+from abc import ABCMeta, abstractmethod
+import datetime
+import math
+import numbers
+import re
+import six
+
+_MYPY = False
+if _MYPY:
+    import typing  # noqa: F401 # pylint: disable=import-error,unused-import,useless-suppression
+
+# See <http://python3porting.com/differences.html#buffer>
+if six.PY3:
+    _binary_types = (bytes, memoryview)  # noqa: E501,F821 # pylint: disable=undefined-variable,useless-suppression
+else:
+    _binary_types = (bytes, buffer)  # noqa: E501,F821 # pylint: disable=undefined-variable,useless-suppression
+
+
+class ValidationError(Exception):
+    """Raised when a value doesn't pass validation by its validator."""
+
+    def __init__(self, message, parent=None):
+        """
+        Args:
+            message (str): Error message detailing validation failure.
+            parent (str): Adds the parent as the closest reference point for
+                the error. Use :meth:`add_parent` to add more.
+        """
+        super(ValidationError, self).__init__(message)
+        self.message = message
+        self._parents = []
+        if parent:
+            self._parents.append(parent)
+
+    def add_parent(self, parent):
+        """
+        Args:
+            parent (str): Adds the parent to the top of the tree of references
+                that lead to the validator that failed.
+        """
+        self._parents.append(parent)
+
+    def __str__(self):
+        """
+        Returns:
+            str: A descriptive message of the validation error that may also
+                include the path to the validator that failed.
+        """
+        if self._parents:
+            return '{}: {}'.format('.'.join(self._parents[::-1]), self.message)
+        else:
+            return self.message
+
+    def __repr__(self):
+        # Not a perfect repr, but includes the error location information.
+        return 'ValidationError(%r)' % six.text_type(self)
+
+
+def generic_type_name(v):
+    """Return a descriptive type name that isn't Python specific. For example,
+    an int value will return 'integer' rather than 'int'."""
+    if isinstance(v, numbers.Integral):
+        # Must come before real numbers check since integrals are reals too
+        return 'integer'
+    elif isinstance(v, numbers.Real):
+        return 'float'
+    elif isinstance(v, (tuple, list)):
+        return 'list'
+    elif isinstance(v, six.string_types):
+        return 'string'
+    elif v is None:
+        return 'null'
+    else:
+        return type(v).__name__
+
+
+class Validator(object):
+    """All primitive and composite data types should be a subclass of this."""
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def validate(self, val):
+        """Validates that val is of this data type.
+
+        Returns: A normalized value if validation succeeds.
+        Raises: ValidationError
+        """
+        pass
+
+    def has_default(self):
+        return False
+
+    def get_default(self):
+        raise AssertionError('No default available.')
+
+
+class Primitive(Validator):
+    """A basic type that is defined by Stone."""
+    # pylint: disable=abstract-method
+    pass
+
+
+class Boolean(Primitive):
+
+    def validate(self, val):
+        if not isinstance(val, bool):
+            raise ValidationError('%r is not a valid boolean' % val)
+        return val
+
+
+class Integer(Primitive):
+    """
+    Do not use this class directly. Extend it and specify a 'minimum' and
+    'maximum' value as class variables for a more restrictive integer range.
+    """
+    minimum = None  # type: typing.Optional[int]
+    maximum = None  # type: typing.Optional[int]
+
+    def __init__(self, min_value=None, max_value=None):
+        """
+        A more restrictive minimum or maximum value can be specified than the
+        range inherent to the defined type.
+        """
+        if min_value is not None:
+            assert isinstance(min_value, numbers.Integral), \
+                'min_value must be an integral number'
+            assert min_value >= self.minimum, \
+                'min_value cannot be less than the minimum value for this ' \
+                'type (%d < %d)' % (min_value, self.minimum)
+            self.minimum = min_value
+        if max_value is not None:
+            assert isinstance(max_value, numbers.Integral), \
+                'max_value must be an integral number'
+            assert max_value <= self.maximum, \
+                'max_value cannot be greater than the maximum value for ' \
+                'this type (%d < %d)' % (max_value, self.maximum)
+            self.maximum = max_value
+
+    def validate(self, val):
+        if not isinstance(val, numbers.Integral):
+            raise ValidationError('expected integer, got %s'
+                                  % generic_type_name(val))
+        elif not (self.minimum <= val <= self.maximum):
+            raise ValidationError('%d is not within range [%d, %d]'
+                                  % (val, self.minimum, self.maximum))
+        return val
+
+    def __repr__(self):
+        return '%s()' % self.__class__.__name__
+
+
+class Int32(Integer):
+    minimum = -2**31
+    maximum = 2**31 - 1
+
+
+class UInt32(Integer):
+    minimum = 0
+    maximum = 2**32 - 1
+
+
+class Int64(Integer):
+    minimum = -2**63
+    maximum = 2**63 - 1
+
+
+class UInt64(Integer):
+    minimum = 0
+    maximum = 2**64 - 1
+
+
+class Real(Primitive):
+    """
+    Do not use this class directly. Extend it and optionally set a 'minimum'
+    and 'maximum' value to enforce a range that's a subset of the Python float
+    implementation. Python floats are doubles.
+    """
+    minimum = None  # type: typing.Optional[float]
+    maximum = None  # type: typing.Optional[float]
+
+    def __init__(self, min_value=None, max_value=None):
+        """
+        A more restrictive minimum or maximum value can be specified than the
+        range inherent to the defined type.
+        """
+        if min_value is not None:
+            assert isinstance(min_value, numbers.Real), \
+                'min_value must be a real number'
+            if not isinstance(min_value, float):
+                try:
+                    min_value = float(min_value)
+                except OverflowError:
+                    raise AssertionError('min_value is too small for a float')
+            if self.minimum is not None and min_value < self.minimum:
+                raise AssertionError('min_value cannot be less than the '
+                                     'minimum value for this type (%f < %f)' %
+                                     (min_value, self.minimum))
+            self.minimum = min_value
+        if max_value is not None:
+            assert isinstance(max_value, numbers.Real), \
+                'max_value must be a real number'
+            if not isinstance(max_value, float):
+                try:
+                    max_value = float(max_value)
+                except OverflowError:
+                    raise AssertionError('max_value is too large for a float')
+            if self.maximum is not None and max_value > self.maximum:
+                raise AssertionError('max_value cannot be greater than the '
+                                     'maximum value for this type (%f < %f)' %
+                                     (max_value, self.maximum))
+            self.maximum = max_value
+
+    def validate(self, val):
+        if not isinstance(val, numbers.Real):
+            raise ValidationError('expected real number, got %s' %
+                                  generic_type_name(val))
+        if not isinstance(val, float):
+            # This checks for the case where a number is passed in with a
+            # magnitude larger than supported by float64.
+            try:
+                val = float(val)
+            except OverflowError:
+                raise ValidationError('too large for float')
+        if math.isnan(val) or math.isinf(val):
+            raise ValidationError('%f values are not supported' % val)
+        if self.minimum is not None and val < self.minimum:
+            raise ValidationError('%f is not greater than %f' %
+                                  (val, self.minimum))
+        if self.maximum is not None and val > self.maximum:
+            raise ValidationError('%f is not less than %f' %
+                                  (val, self.maximum))
+        return val
+
+    def __repr__(self):
+        return '%s()' % self.__class__.__name__
+
+
+class Float32(Real):
+    # Maximum and minimums from the IEEE 754-1985 standard
+    minimum = -3.40282 * 10**38
+    maximum = 3.40282 * 10**38
+
+
+class Float64(Real):
+    pass
+
+
+class String(Primitive):
+    """Represents a unicode string."""
+
+    def __init__(self, min_length=None, max_length=None, pattern=None):
+        if min_length is not None:
+            assert isinstance(min_length, numbers.Integral), \
+                'min_length must be an integral number'
+            assert min_length >= 0, 'min_length must be >= 0'
+        if max_length is not None:
+            assert isinstance(max_length, numbers.Integral), \
+                'max_length must be an integral number'
+            assert max_length > 0, 'max_length must be > 0'
+        if min_length and max_length:
+            assert max_length >= min_length, 'max_length must be >= min_length'
+        if pattern is not None:
+            assert isinstance(pattern, six.string_types), \
+                'pattern must be a string'
+
+        self.min_length = min_length
+        self.max_length = max_length
+        self.pattern = pattern
+        self.pattern_re = None
+
+        if pattern:
+            try:
+                self.pattern_re = re.compile(r"\A(?:" + pattern + r")\Z")
+            except re.error as e:
+                raise AssertionError('Regex {!r} failed: {}'.format(
+                    pattern, e.args[0]))
+
+    def validate(self, val):
+        """
+        A unicode string of the correct length and pattern will pass validation.
+        In PY2, we enforce that a str type must be valid utf-8, and a unicode
+        string will be returned.
+        """
+        if not isinstance(val, six.string_types):
+            raise ValidationError("'%s' expected to be a string, got %s"
+                                  % (val, generic_type_name(val)))
+        if not six.PY3 and isinstance(val, str):
+            try:
+                val = val.decode('utf-8')
+            except UnicodeDecodeError:
+                raise ValidationError("'%s' was not valid utf-8")
+
+        if self.max_length is not None and len(val) > self.max_length:
+            raise ValidationError("'%s' must be at most %d characters, got %d"
+                                  % (val, self.max_length, len(val)))
+        if self.min_length is not None and len(val) < self.min_length:
+            raise ValidationError("'%s' must be at least %d characters, got %d"
+                                  % (val, self.min_length, len(val)))
+
+        if self.pattern and not self.pattern_re.match(val):
+            raise ValidationError("'%s' did not match pattern '%s'"
+                                  % (val, self.pattern))
+        return val
+
+
+class Bytes(Primitive):
+
+    def __init__(self, min_length=None, max_length=None):
+        if min_length is not None:
+            assert isinstance(min_length, numbers.Integral), \
+                'min_length must be an integral number'
+            assert min_length >= 0, 'min_length must be >= 0'
+        if max_length is not None:
+            assert isinstance(max_length, numbers.Integral), \
+                'max_length must be an integral number'
+            assert max_length > 0, 'max_length must be > 0'
+        if min_length is not None and max_length is not None:
+            assert max_length >= min_length, 'max_length must be >= min_length'
+
+        self.min_length = min_length
+        self.max_length = max_length
+
+    def validate(self, val):
+        if not isinstance(val, _binary_types):
+            raise ValidationError("expected bytes type, got %s"
+                                  % generic_type_name(val))
+        elif self.max_length is not None and len(val) > self.max_length:
+            raise ValidationError("'%s' must have at most %d bytes, got %d"
+                                  % (val, self.max_length, len(val)))
+        elif self.min_length is not None and len(val) < self.min_length:
+            raise ValidationError("'%s' has fewer than %d bytes, got %d"
+                                  % (val, self.min_length, len(val)))
+        return val
+
+
+class Timestamp(Primitive):
+    """Note that while a format is specified, it isn't used in validation
+    since a native Python datetime object is preferred. The format, however,
+    can and should be used by serializers."""
+
+    def __init__(self, fmt):
+        """fmt must be composed of format codes that the C standard (1989)
+        supports, most notably in its strftime() function."""
+        assert isinstance(fmt, six.text_type), 'format must be a string'
+        self.format = fmt
+
+    def validate(self, val):
+        if not isinstance(val, datetime.datetime):
+            raise ValidationError('expected timestamp, got %s'
+                                  % generic_type_name(val))
+        elif val.tzinfo is not None and \
+                val.tzinfo.utcoffset(val).total_seconds() != 0:
+            raise ValidationError('timestamp should have either a UTC '
+                                  'timezone or none set at all')
+        return val
+
+
+class Composite(Validator):
+    """Validator for a type that builds on other primitive and composite
+    types."""
+    # pylint: disable=abstract-method
+    pass
+
+
+class List(Composite):
+    """Assumes list contents are homogeneous with respect to types."""
+
+    def __init__(self, item_validator, min_items=None, max_items=None):
+        """Every list item will be validated with item_validator."""
+        self.item_validator = item_validator
+        if min_items is not None:
+            assert isinstance(min_items, numbers.Integral), \
+                'min_items must be an integral number'
+            assert min_items >= 0, 'min_items must be >= 0'
+        if max_items is not None:
+            assert isinstance(max_items, numbers.Integral), \
+                'max_items must be an integral number'
+            assert max_items > 0, 'max_items must be > 0'
+        if min_items is not None and max_items is not None:
+            assert max_items >= min_items, 'max_items must be >= min_items'
+
+        self.min_items = min_items
+        self.max_items = max_items
+
+    def validate(self, val):
+        if not isinstance(val, (tuple, list)):
+            raise ValidationError('%r is not a valid list' % val)
+        elif self.max_items is not None and len(val) > self.max_items:
+            raise ValidationError('%r has more than %s items'
+                                  % (val, self.max_items))
+        elif self.min_items is not None and len(val) < self.min_items:
+            raise ValidationError('%r has fewer than %s items'
+                                  % (val, self.min_items))
+        return [self.item_validator.validate(item) for item in val]
+
+
+class Map(Composite):
+    """Assumes map keys and values are homogeneous with respect to types."""
+
+    def __init__(self, key_validator, value_validator):
+        """
+        Every Map key/value pair will be validated with item_validator.
+        key validators must be a subclass of a String validator
+        """
+        self.key_validator = key_validator
+        self.value_validator = value_validator
+
+    def validate(self, val):
+        if not isinstance(val, dict):
+            raise ValidationError('%r is not a valid dict' % val)
+        return {
+            self.key_validator.validate(key):
+                self.value_validator.validate(value) for key, value in val.items()
+        }
+
+
+class Struct(Composite):
+
+    def __init__(self, definition):
+        """
+        Args:
+            definition (class): A generated class representing a Stone struct
+                from a spec. Must have a _fields_ attribute with the following
+                structure:
+
+                _fields_ = [(field_name, validator), ...]
+
+                where
+                    field_name: Name of the field (str).
+                    validator: Validator object.
+        """
+        super(Struct, self).__init__()
+        self.definition = definition
+
+    def validate(self, val):
+        """
+        For a val to pass validation, val must be of the correct type and have
+        all required fields present.
+        """
+        self.validate_type_only(val)
+        self.validate_fields_only(val)
+        return val
+
+    def validate_fields_only(self, val):
+        """
+        To pass field validation, no required field should be missing.
+
+        This method assumes that the contents of each field have already been
+        validated on assignment, so it's merely a presence check.
+
+        FIXME(kelkabany): Since the definition object does not maintain a list
+        of which fields are required, all fields are scanned.
+        """
+        for field_name, _ in self.definition._all_fields_:
+            if not hasattr(val, field_name):
+                raise ValidationError("missing required field '%s'" %
+                                      field_name)
+
+    def validate_type_only(self, val):
+        """
+        Use this when you only want to validate that the type of an object
+        is correct, but not yet validate each field.
+        """
+        # Since the definition maintains the list of fields for serialization,
+        # we're okay with a subclass that might have extra information. This
+        # makes it easier to return one subclass for two routes, one of which
+        # relies on the parent class.
+        if not isinstance(val, self.definition):
+            raise ValidationError('expected type %s, got %s' %
+                (self.definition.__name__, generic_type_name(val)))
+
+    def has_default(self):
+        return not self.definition._has_required_fields
+
+    def get_default(self):
+        assert not self.definition._has_required_fields, 'No default available.'
+        return self.definition()
+
+
+class StructTree(Struct):
+    """Validator for structs with enumerated subtypes.
+
+    NOTE: validate_fields_only() validates the fields known to this base
+    struct, but does not do any validation specific to the subtype.
+    """
+
+    # See PyCQA/pylint#1043 for why this is disabled; this should show up
+    # as a usless-suppression (and can be removed) once a fix is released
+    def __init__(self, definition):  # pylint: disable=useless-super-delegation
+        super(StructTree, self).__init__(definition)
+
+
+class Union(Composite):
+
+    def __init__(self, definition):
+        """
+        Args:
+            definition (class): A generated class representing a Stone union
+                from a spec. Must have a _tagmap attribute with the following
+                structure:
+
+                _tagmap = {field_name: validator, ...}
+
+                where
+                    field_name (str): Tag name.
+                    validator (Validator): Tag value validator.
+        """
+        self.definition = definition
+
+    def validate(self, val):
+        """
+        For a val to pass validation, it must have a _tag set. This assumes
+        that the object validated that _tag is a valid tag, and that any
+        associated value has also been validated.
+        """
+        self.validate_type_only(val)
+        if not hasattr(val, '_tag') or val._tag is None:
+            raise ValidationError('no tag set')
+        return val
+
+    def validate_type_only(self, val):
+        """
+        Use this when you only want to validate that the type of an object
+        is correct, but not yet validate each field.
+
+        We check whether val is a Python parent class of the definition. This
+        is because Union subtyping works in the opposite direction of Python
+        inheritance. For example, if a union U2 extends U1 in Python, this
+        validator will accept U1 in places where U2 is expected.
+        """
+        if not issubclass(self.definition, type(val)):
+            raise ValidationError('expected type %s or subtype, got %s' %
+                (self.definition.__name__, generic_type_name(val)))
+
+
+class Void(Primitive):
+
+    def validate(self, val):
+        if val is not None:
+            raise ValidationError('expected NoneType, got %s' %
+                                  generic_type_name(val))
+
+    def has_default(self):
+        return True
+
+    def get_default(self):
+        return None
+
+
+class Nullable(Validator):
+
+    def __init__(self, validator):
+        assert isinstance(validator, (Primitive, Composite)), \
+            'validator must be for a primitive or composite type'
+        assert not isinstance(validator, Nullable), \
+            'nullables cannot be stacked'
+        assert not isinstance(validator, Void), \
+            'void cannot be made nullable'
+        self.validator = validator
+
+    def validate(self, val):
+        if val is None:
+            return
+        else:
+            return self.validator.validate(val)
+
+    def validate_type_only(self, val):
+        """Use this only if Nullable is wrapping a Composite."""
+        if val is None:
+            return
+        else:
+            return self.validator.validate_type_only(val)
+
+    def has_default(self):
+        return True
+
+    def get_default(self):
+        return None

resources/lib/dropbox/team_common.py

@@ -0,0 +1,468 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+try:
+    from . import (
+        common,
+    )
+except (SystemError, ValueError):
+    import common
+
+class GroupManagementType(bb.Union):
+    """
+    The group type determines how a group is managed.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar user_managed: A group which is managed by selected users.
+    :ivar company_managed: A group which is managed by team admins only.
+    :ivar system_managed: A group which is managed automatically by Dropbox.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    user_managed = None
+    # Attribute is overwritten below the class definition
+    company_managed = None
+    # Attribute is overwritten below the class definition
+    system_managed = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_user_managed(self):
+        """
+        Check if the union tag is ``user_managed``.
+
+        :rtype: bool
+        """
+        return self._tag == 'user_managed'
+
+    def is_company_managed(self):
+        """
+        Check if the union tag is ``company_managed``.
+
+        :rtype: bool
+        """
+        return self._tag == 'company_managed'
+
+    def is_system_managed(self):
+        """
+        Check if the union tag is ``system_managed``.
+
+        :rtype: bool
+        """
+        return self._tag == 'system_managed'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'GroupManagementType(%r, %r)' % (self._tag, self._value)
+
+GroupManagementType_validator = bv.Union(GroupManagementType)
+
+class GroupSummary(object):
+    """
+    Information about a group.
+
+    :ivar group_external_id: External ID of group. This is an arbitrary ID that
+        an admin can attach to a group.
+    :ivar member_count: The number of members in the group.
+    :ivar group_management_type: Who is allowed to manage the group.
+    """
+
+    __slots__ = [
+        '_group_name_value',
+        '_group_name_present',
+        '_group_id_value',
+        '_group_id_present',
+        '_group_external_id_value',
+        '_group_external_id_present',
+        '_member_count_value',
+        '_member_count_present',
+        '_group_management_type_value',
+        '_group_management_type_present',
+    ]
+
+    _has_required_fields = True
+
+    def __init__(self,
+                 group_name=None,
+                 group_id=None,
+                 group_management_type=None,
+                 group_external_id=None,
+                 member_count=None):
+        self._group_name_value = None
+        self._group_name_present = False
+        self._group_id_value = None
+        self._group_id_present = False
+        self._group_external_id_value = None
+        self._group_external_id_present = False
+        self._member_count_value = None
+        self._member_count_present = False
+        self._group_management_type_value = None
+        self._group_management_type_present = False
+        if group_name is not None:
+            self.group_name = group_name
+        if group_id is not None:
+            self.group_id = group_id
+        if group_external_id is not None:
+            self.group_external_id = group_external_id
+        if member_count is not None:
+            self.member_count = member_count
+        if group_management_type is not None:
+            self.group_management_type = group_management_type
+
+    @property
+    def group_name(self):
+        """
+        :rtype: str
+        """
+        if self._group_name_present:
+            return self._group_name_value
+        else:
+            raise AttributeError("missing required field 'group_name'")
+
+    @group_name.setter
+    def group_name(self, val):
+        val = self._group_name_validator.validate(val)
+        self._group_name_value = val
+        self._group_name_present = True
+
+    @group_name.deleter
+    def group_name(self):
+        self._group_name_value = None
+        self._group_name_present = False
+
+    @property
+    def group_id(self):
+        """
+        :rtype: str
+        """
+        if self._group_id_present:
+            return self._group_id_value
+        else:
+            raise AttributeError("missing required field 'group_id'")
+
+    @group_id.setter
+    def group_id(self, val):
+        val = self._group_id_validator.validate(val)
+        self._group_id_value = val
+        self._group_id_present = True
+
+    @group_id.deleter
+    def group_id(self):
+        self._group_id_value = None
+        self._group_id_present = False
+
+    @property
+    def group_external_id(self):
+        """
+        External ID of group. This is an arbitrary ID that an admin can attach
+        to a group.
+
+        :rtype: str
+        """
+        if self._group_external_id_present:
+            return self._group_external_id_value
+        else:
+            return None
+
+    @group_external_id.setter
+    def group_external_id(self, val):
+        if val is None:
+            del self.group_external_id
+            return
+        val = self._group_external_id_validator.validate(val)
+        self._group_external_id_value = val
+        self._group_external_id_present = True
+
+    @group_external_id.deleter
+    def group_external_id(self):
+        self._group_external_id_value = None
+        self._group_external_id_present = False
+
+    @property
+    def member_count(self):
+        """
+        The number of members in the group.
+
+        :rtype: long
+        """
+        if self._member_count_present:
+            return self._member_count_value
+        else:
+            return None
+
+    @member_count.setter
+    def member_count(self, val):
+        if val is None:
+            del self.member_count
+            return
+        val = self._member_count_validator.validate(val)
+        self._member_count_value = val
+        self._member_count_present = True
+
+    @member_count.deleter
+    def member_count(self):
+        self._member_count_value = None
+        self._member_count_present = False
+
+    @property
+    def group_management_type(self):
+        """
+        Who is allowed to manage the group.
+
+        :rtype: GroupManagementType
+        """
+        if self._group_management_type_present:
+            return self._group_management_type_value
+        else:
+            raise AttributeError("missing required field 'group_management_type'")
+
+    @group_management_type.setter
+    def group_management_type(self, val):
+        self._group_management_type_validator.validate_type_only(val)
+        self._group_management_type_value = val
+        self._group_management_type_present = True
+
+    @group_management_type.deleter
+    def group_management_type(self):
+        self._group_management_type_value = None
+        self._group_management_type_present = False
+
+    def __repr__(self):
+        return 'GroupSummary(group_name={!r}, group_id={!r}, group_management_type={!r}, group_external_id={!r}, member_count={!r})'.format(
+            self._group_name_value,
+            self._group_id_value,
+            self._group_management_type_value,
+            self._group_external_id_value,
+            self._member_count_value,
+        )
+
+GroupSummary_validator = bv.Struct(GroupSummary)
+
+class GroupType(bb.Union):
+    """
+    The group type determines how a group is created and managed.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar team: A group to which team members are automatically added.
+        Applicable to `team folders <https://www.dropbox.com/help/986>`_ only.
+    :ivar user_managed: A group is created and managed by a user.
+    """
+
+    _catch_all = 'other'
+    # Attribute is overwritten below the class definition
+    team = None
+    # Attribute is overwritten below the class definition
+    user_managed = None
+    # Attribute is overwritten below the class definition
+    other = None
+
+    def is_team(self):
+        """
+        Check if the union tag is ``team``.
+
+        :rtype: bool
+        """
+        return self._tag == 'team'
+
+    def is_user_managed(self):
+        """
+        Check if the union tag is ``user_managed``.
+
+        :rtype: bool
+        """
+        return self._tag == 'user_managed'
+
+    def is_other(self):
+        """
+        Check if the union tag is ``other``.
+
+        :rtype: bool
+        """
+        return self._tag == 'other'
+
+    def __repr__(self):
+        return 'GroupType(%r, %r)' % (self._tag, self._value)
+
+GroupType_validator = bv.Union(GroupType)
+
+class TimeRange(object):
+    """
+    Time range.
+
+    :ivar start_time: Optional starting time (inclusive).
+    :ivar end_time: Optional ending time (exclusive).
+    """
+
+    __slots__ = [
+        '_start_time_value',
+        '_start_time_present',
+        '_end_time_value',
+        '_end_time_present',
+    ]
+
+    _has_required_fields = False
+
+    def __init__(self,
+                 start_time=None,
+                 end_time=None):
+        self._start_time_value = None
+        self._start_time_present = False
+        self._end_time_value = None
+        self._end_time_present = False
+        if start_time is not None:
+            self.start_time = start_time
+        if end_time is not None:
+            self.end_time = end_time
+
+    @property
+    def start_time(self):
+        """
+        Optional starting time (inclusive).
+
+        :rtype: datetime.datetime
+        """
+        if self._start_time_present:
+            return self._start_time_value
+        else:
+            return None
+
+    @start_time.setter
+    def start_time(self, val):
+        if val is None:
+            del self.start_time
+            return
+        val = self._start_time_validator.validate(val)
+        self._start_time_value = val
+        self._start_time_present = True
+
+    @start_time.deleter
+    def start_time(self):
+        self._start_time_value = None
+        self._start_time_present = False
+
+    @property
+    def end_time(self):
+        """
+        Optional ending time (exclusive).
+
+        :rtype: datetime.datetime
+        """
+        if self._end_time_present:
+            return self._end_time_value
+        else:
+            return None
+
+    @end_time.setter
+    def end_time(self, val):
+        if val is None:
+            del self.end_time
+            return
+        val = self._end_time_validator.validate(val)
+        self._end_time_value = val
+        self._end_time_present = True
+
+    @end_time.deleter
+    def end_time(self):
+        self._end_time_value = None
+        self._end_time_present = False
+
+    def __repr__(self):
+        return 'TimeRange(start_time={!r}, end_time={!r})'.format(
+            self._start_time_value,
+            self._end_time_value,
+        )
+
+TimeRange_validator = bv.Struct(TimeRange)
+
+GroupExternalId_validator = bv.String()
+GroupId_validator = bv.String()
+MemberExternalId_validator = bv.String(max_length=64)
+ResellerId_validator = bv.String()
+TeamMemberId_validator = bv.String()
+GroupManagementType._user_managed_validator = bv.Void()
+GroupManagementType._company_managed_validator = bv.Void()
+GroupManagementType._system_managed_validator = bv.Void()
+GroupManagementType._other_validator = bv.Void()
+GroupManagementType._tagmap = {
+    'user_managed': GroupManagementType._user_managed_validator,
+    'company_managed': GroupManagementType._company_managed_validator,
+    'system_managed': GroupManagementType._system_managed_validator,
+    'other': GroupManagementType._other_validator,
+}
+
+GroupManagementType.user_managed = GroupManagementType('user_managed')
+GroupManagementType.company_managed = GroupManagementType('company_managed')
+GroupManagementType.system_managed = GroupManagementType('system_managed')
+GroupManagementType.other = GroupManagementType('other')
+
+GroupSummary._group_name_validator = bv.String()
+GroupSummary._group_id_validator = GroupId_validator
+GroupSummary._group_external_id_validator = bv.Nullable(GroupExternalId_validator)
+GroupSummary._member_count_validator = bv.Nullable(bv.UInt32())
+GroupSummary._group_management_type_validator = GroupManagementType_validator
+GroupSummary._all_field_names_ = set([
+    'group_name',
+    'group_id',
+    'group_external_id',
+    'member_count',
+    'group_management_type',
+])
+GroupSummary._all_fields_ = [
+    ('group_name', GroupSummary._group_name_validator),
+    ('group_id', GroupSummary._group_id_validator),
+    ('group_external_id', GroupSummary._group_external_id_validator),
+    ('member_count', GroupSummary._member_count_validator),
+    ('group_management_type', GroupSummary._group_management_type_validator),
+]
+
+GroupType._team_validator = bv.Void()
+GroupType._user_managed_validator = bv.Void()
+GroupType._other_validator = bv.Void()
+GroupType._tagmap = {
+    'team': GroupType._team_validator,
+    'user_managed': GroupType._user_managed_validator,
+    'other': GroupType._other_validator,
+}
+
+GroupType.team = GroupType('team')
+GroupType.user_managed = GroupType('user_managed')
+GroupType.other = GroupType('other')
+
+TimeRange._start_time_validator = bv.Nullable(common.DropboxTimestamp_validator)
+TimeRange._end_time_validator = bv.Nullable(common.DropboxTimestamp_validator)
+TimeRange._all_field_names_ = set([
+    'start_time',
+    'end_time',
+])
+TimeRange._all_fields_ = [
+    ('start_time', TimeRange._start_time_validator),
+    ('end_time', TimeRange._end_time_validator),
+]
+
+ROUTES = {
+}
+

resources/lib/dropbox/users_common.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# Auto-generated by Stone, do not modify.
+# flake8: noqa
+# pylint: skip-file
+"""
+This namespace contains common data types used within the users namespace.
+"""
+
+try:
+    from . import stone_validators as bv
+    from . import stone_base as bb
+except (SystemError, ValueError):
+    # Catch errors raised when importing a relative module when not in a package.
+    # This makes testing this file directly (outside of a package) easier.
+    import stone_validators as bv
+    import stone_base as bb
+
+class AccountType(bb.Union):
+    """
+    What type of account this user has.
+
+    This class acts as a tagged union. Only one of the ``is_*`` methods will
+    return true. To get the associated value of a tag (if one exists), use the
+    corresponding ``get_*`` method.
+
+    :ivar basic: The basic account type.
+    :ivar pro: The Dropbox Pro account type.
+    :ivar business: The Dropbox Business account type.
+    """
+
+    _catch_all = None
+    # Attribute is overwritten below the class definition
+    basic = None
+    # Attribute is overwritten below the class definition
+    pro = None
+    # Attribute is overwritten below the class definition
+    business = None
+
+    def is_basic(self):
+        """
+        Check if the union tag is ``basic``.
+
+        :rtype: bool
+        """
+        return self._tag == 'basic'
+
+    def is_pro(self):
+        """
+        Check if the union tag is ``pro``.
+
+        :rtype: bool
+        """
+        return self._tag == 'pro'
+
+    def is_business(self):
+        """
+        Check if the union tag is ``business``.
+
+        :rtype: bool
+        """
+        return self._tag == 'business'
+
+    def __repr__(self):
+        return 'AccountType(%r, %r)' % (self._tag, self._value)
+
+AccountType_validator = bv.Union(AccountType)
+
+AccountId_validator = bv.String(min_length=40, max_length=40)
+AccountType._basic_validator = bv.Void()
+AccountType._pro_validator = bv.Void()
+AccountType._business_validator = bv.Void()
+AccountType._tagmap = {
+    'basic': AccountType._basic_validator,
+    'pro': AccountType._pro_validator,
+    'business': AccountType._business_validator,
+}
+
+AccountType.basic = AccountType('basic')
+AccountType.pro = AccountType('pro')
+AccountType.business = AccountType('business')
+
+ROUTES = {
+}
+

resources/lib/pydrive/auth.py

@@ -3,17 +3,16 @@ import webbrowser
 import httplib2
 import oauth2client.clientsecrets as clientsecrets
 
-from apiclient.discovery import build
+from googleapiclient.discovery import build
 from functools import wraps
 from oauth2client.client import FlowExchangeError
 from oauth2client.client import AccessTokenRefreshError
 from oauth2client.client import OAuth2WebServerFlow
 from oauth2client.client import OOB_CALLBACK_URN
 from oauth2client.file import Storage
-from oauth2client.file import CredentialsFileSymbolicLinkError
 from oauth2client.tools import ClientRedirectHandler
 from oauth2client.tools import ClientRedirectServer
-from oauth2client.util import scopes_to_string
+from oauth2client._helpers import scopes_to_string
 from .apiattr import ApiAttribute
 from .apiattr import ApiAttributeMixin
 from .settings import LoadSettingsFile
@@ -234,7 +233,7 @@ class GoogleAuth(ApiAttributeMixin, object):
     try:
       storage = Storage(credentials_file)
       self.credentials = storage.get()
-    except CredentialsFileSymbolicLinkError:
+    except IOError:
       raise InvalidCredentialsError('Credentials file cannot be symbolic link')
 
   def SaveCredentials(self, backend=None):

resources/lib/pydrive/files.py

@@ -1,8 +1,8 @@
 import io
 import mimetypes
 
-from apiclient import errors
-from apiclient.http import MediaIoBaseUpload
+from googleapiclient import errors
+from googleapiclient.http import MediaIoBaseUpload
 from functools import wraps
 
 from .apiattr import ApiAttribute

resources/lib/vfs.py

@@ -7,7 +7,8 @@ import zipfile
 import zlib
 import os
 import sys
-from dropbox import client
+import dropbox
+from dropbox.files import WriteMode
 from pydrive.drive import GoogleDrive
 from authorizers import DropboxAuthorizer,GoogleDriveAuthorizer
 
@@ -134,16 +135,18 @@ class DropboxFileSystem(Vfs):
             sys.exit()
 
     def listdir(self,directory):
+        directory = self._fix_slashes(directory)
+        
         if(self.client != None and self.exists(directory)):
             files = []
             dirs = []
-            metadata = self.client.metadata(directory)
+            metadata = self.client.files_list_folder(directory)
 
-            for aFile in metadata['contents']:
-                if(aFile['is_dir']):
-                    dirs.append(utils.encode(aFile['path'][len(directory):]))
+            for aFile in metadata.entries:
+                if(isinstance(aFile,dropbox.files.FolderMetadata)):
+                    dirs.append(utils.encode(aFile.name))
                 else:
-                    files.append(utils.encode(aFile['path'][len(directory):]))
+                    files.append(utils.encode(aFile.name))
 
             return [dirs,files]
         else:
@@ -153,8 +156,7 @@ class DropboxFileSystem(Vfs):
     def mkdir(self,directory):
         directory = self._fix_slashes(directory)
         if(self.client != None):
-            if(not self.exists(directory)):
-                self.client.file_create_folder(directory)
+            #sort of odd but always return true, folder create is implicit with file upload
             return True
         else:
             return False
@@ -169,7 +171,7 @@ class DropboxFileSystem(Vfs):
                 self.rmdir(aDir)
 
             #finally remove the root directory
-            self.client.file_delete(directory)
+            self.client.files_delete(directory)
             
             return True
         else:
@@ -179,16 +181,21 @@ class DropboxFileSystem(Vfs):
         aFile = self._fix_slashes(aFile)
         
         if(self.client != None and self.exists(aFile)):
-            self.client.file_delete(aFile)
+            self.client.files_delete(aFile)
             return True
         else:
             return False
 
     def exists(self,aFile):
         aFile = self._fix_slashes(aFile)
+    
         if(self.client != None):
+            #can't list root metadata
+            if(aFile == ''):
+                return True
+            
             try:
-                meta_data = self.client.metadata(aFile)
+                meta_data = self.client.files_get_metadata(aFile)
                 #if we make it here the file does exist
                 return True
             except:
@@ -202,7 +209,7 @@ class DropboxFileSystem(Vfs):
         if(self.client != None):
             f = open(source,'rb')
             try:
-                response = self.client.put_file(dest,f,True)
+                response = self.client.files_upload(f.read(),dest,mode=WriteMode('overwrite'))
                 return True
             except:
                 #if we have an exception retry
@@ -217,16 +224,18 @@ class DropboxFileSystem(Vfs):
     def get_file(self,source,dest):
         if(self.client != None):
             #write the file locally
-            out = open(dest,'wb')
-            f = self.client.get_file(source).read()
-            out.write(f)
-            out.close()
+            f = self.client.files_download_to_file(dest,source)
             return True
         else:
             return False
 
     def _fix_slashes(self,filename):
-        return filename.replace('\\','/')
+        result = filename.replace('\\','/')
+
+        if(result == '/'):
+            result = ""
+
+        return result
             
 
 class GoogleDriveFilesystem(Vfs):