Navigation

DropboxClient

The main client API you’ll be working with most often. You’ll need to configure a dropbox.session.DropboxSession for this to work, but otherwise it’s fairly self-explanatory.

Before you can begin making requests to the dropbox API, you have to authenticate your application with Dropbox and get the user to authorize your application to use dropbox on his behalf. A typical progam, from the initial imports to making a simple request (account_info), looks like this:

# Include the Dropbox SDK libraries
from dropbox import client, rest, session

# Get your app key and secret from the Dropbox developer website
APP_KEY = 'INSERT_APP_KEY_HERE'
APP_SECRET = 'INSERT_SECRET_HERE'

# ACCESS_TYPE should be 'dropbox' or 'app_folder' as configured for your app
ACCESS_TYPE = 'INSERT_ACCESS_TYPE_HERE'

sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)

request_token = sess.obtain_request_token()

url = sess.build_authorize_url(request_token)

# Make the user sign in and authorize this token
print "url:", url
print "Please visit this website and press the 'Allow' button, then hit 'Enter' here."
raw_input()

# This will fail if the user didn't visit the above URL and hit 'Allow'
access_token = sess.obtain_access_token(request_token)

client = client.DropboxClient(sess)
print "linked account:", client.account_info()
class dropbox.client.DropboxClient(session, rest_client=<class 'dropbox.rest.RESTClient'>)

The main access point of doing REST calls on Dropbox. You should first create and configure a dropbox.session.DropboxSession object, and then pass it into DropboxClient’s constructor. DropboxClient then does all the work of properly calling each API method with the correct OAuth authentication.

You should be aware that any of these methods can raise a rest.ErrorResponse exception if the server returns a non-200 or invalid HTTP response. Note that a 401 return status at any point indicates that the user needs to be reauthenticated.

class ChunkedUploader(client, file_obj, length)

Contains the logic around a chunked upload, which uploads a large file to Dropbox via the /chunked_upload endpoint

finish(path, overwrite=False, parent_rev=None)

Commits the bytes uploaded by this ChunkedUploader to a file in the users dropbox.

Args:
  • path: The full path of the file in the Dropbox.
  • overwrite: Whether to overwrite an existing file at the given path. [default False] If overwrite is False and a file already exists there, Dropbox will rename the upload to make sure it doesn’t overwrite anything. You need to check the metadata returned for the new name. This field should only be True if your intent is to potentially clobber changes to a file that you don’t know about.
  • parent_rev: The rev field from the ‘parent’ of this upload. [optional] If your intent is to update the file at the given path, you should pass the parent_rev parameter set to the rev value from the most recent metadata you have of the existing file at that path. If the server has a more recent version of the file at the specified path, it will automatically rename your uploaded file, spinning off a conflict. Using this parameter effectively causes the overwrite parameter to be ignored. The file will always be overwritten if you send the most-recent parent_rev, and it will never be overwritten if you send a less-recent one.
upload_chunked(chunk_size=4194304)

Uploads data from this ChunkedUploader’s file_obj in chunks, until an error occurs. Throws an exception when an error occurs, and can be called again to resume the upload.

Args:
  • chunk_size: The number of bytes to put in each chunk. [default 4 MB]
DropboxClient.account_info()

Retrieve information about the user’s account.

Returns:
DropboxClient.add_copy_ref(copy_ref, to_path)

Adds the file referenced by the copy ref to the specified path

Args:
  • copy_ref: A copy ref string that was returned from a create_copy_ref call. The copy_ref can be created from any other Dropbox account, or from the same account.
  • path: The path to where the file will be created.
Returns:
  • A dictionary containing the metadata of the new copy of the file.
DropboxClient.create_copy_ref(from_path)

Creates and returns a copy ref for a specific file. The copy ref can be used to instantly copy that file to the Dropbox of another account.

Args:
  • path: The path to the file for a copy ref to be created on.
Returns:

  • A dictionary that looks like the following example:

    {"expires":"Fri, 31 Jan 2042 21:01:05 +0000", "copy_ref":"z1X6ATl6aWtzOGq0c3g5Ng"}

DropboxClient.delta(cursor=None)

A way of letting you keep up with changes to files and folders in a user’s Dropbox. You can periodically call delta() to get a list of “delta entries”, which are instructions on how to update your local state to match the server’s state.

Arguments:
  • cursor: On the first call, omit this argument (or pass in None). On subsequent calls, pass in the cursor string returned by the previous call.
Returns: A dict with three fields.
  • entries: A list of “delta entries” (described below)
  • reset: If True, you should your local state to be an empty folder before processing the list of delta entries. This is only True only in rare situations.
  • cursor: A string that is used to keep track of your current state. On the next call to delta(), pass in this value to return entries that were recorded since the cursor was returned.
  • has_more: If True, then there are more entries available; you can call delta() again immediately to retrieve those entries. If False, then wait at least 5 minutes (preferably longer) before checking again.
Delta Entries: Each entry is a 2-item list of one of following forms:
  • [path, metadata]: Indicates that there is a file/folder at the given path. You should add the entry to your local path. (The metadata value is the same as what would be returned by the metadata() call.)
    • If the new entry includes parent folders that don’t yet exist in your local state, create those parent folders in your local state. You will eventually get entries for those parent folders.
    • If the new entry is a file, replace whatever your local state has at path with the new entry.
    • If the new entry is a folder, check what your local state has at path. If it’s a file, replace it with the new entry. If it’s a folder, apply the new metadata to the folder, but do not modify the folder’s children.
  • [path, nil]: Indicates that there is no file/folder at the path on Dropbox. To update your local state to match, delete whatever is at path, including any children (you will sometimes also get “delete” delta entries for the children, but this is not guaranteed). If your local state doesn’t have anything at path, ignore this entry.

Remember: Dropbox treats file names in a case-insensitive but case-preserving way. To facilitate this, the path strings above are lower-cased versions of the actual path. The metadata dicts have the original, case-preserved path.

DropboxClient.file_copy(from_path, to_path)

Copy a file or folder to a new location.

Args:
  • from_path: The path to the file or folder to be copied.
  • to_path: The destination path of the file or folder to be copied. This parameter should include the destination filename (e.g. from_path: ‘/test.txt’, to_path: ‘/dir/test.txt’). If there’s already a file at the to_path, this copy will be renamed to be unique.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of:
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No file was found at given from_path.
    • 503: User over storage quota.
DropboxClient.file_create_folder(path)

Create a folder.

Args:
  • path: The path of the new folder.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details) - 403: A folder at that path already exists.
DropboxClient.file_delete(path)

Delete a file or folder.

Args:
  • path: The path of the file or folder.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No file was found at the given path.
DropboxClient.file_move(from_path, to_path)

Move a file or folder to a new location.

Args:
  • from_path: The path to the file or folder to be moved.
  • to_path: The destination path of the file or folder to be moved. This parameter should include the destination filename (e.g.
  • from_path: ‘/test.txt’, to_path: ‘/dir/test.txt’). If there’s already a file at the to_path, this file or folder will be renamed to be unique.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No file was found at given from_path.
    • 503: User over storage quota.
DropboxClient.get_chunked_uploader(file_obj, length)

Creates a ChunkedUploader to upload the given file-like object.

Args:
  • file_obj: The file-like object which is the source of the data being uploaded.
  • length: The number of bytes to upload.

The expected use of this function is as follows:

bigFile = open("data.txt", 'rb')

uploader = myclient.get_chunked_uploader(bigFile, size)
print "uploading: ", size
while uploader.offset < size:
    try:
        upload = uploader.upload_chunked()
    except rest.ErrorResponse, e:
        # perform error handling and retry logic

The SDK leaves the error handling and retry logic to the developer to implement, as the exact requirements will depend on the application involved.

DropboxClient.get_file(from_path, rev=None)

Download a file.

Unlike most other calls, get_file returns a raw HTTPResponse with the connection open. You should call .read() and perform any processing you need, then close the HTTPResponse.

A typical usage looks like this:

out = open('magnum-opus.txt', 'w')
f, metadata = client.get_file_and_metadata('/magnum-opus.txt').read()
out.write(f)

which would download the file magnum-opus.txt and write the contents into the file magnum-opus.txt on the local filesystem.

Args:
  • from_path: The path to the file to be downloaded.
  • rev: A previous rev value of the file to be downloaded. [optional]
Returns:
  • An httplib.HTTPResponse that is the result of the request.
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details) - 404: No file was found at the given path, or the file that was there was deleted. - 200: Request was okay but response was malformed in some way.
DropboxClient.get_file_and_metadata(from_path, rev=None)

Download a file alongwith its metadata.

Acts as a thin wrapper around get_file() (see get_file() comments for more details)

Args:
  • from_path: The path to the file to be downloaded.
  • rev: A previous rev value of the file to be downloaded. [optional]
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details) - 404: No file was found at the given path, or the file that was there was deleted. - 200: Request was okay but response was malformed in some way.
DropboxClient.media(path)

Get a temporary unauthenticated URL for a media file.

All of Dropbox’s API methods require OAuth, which may cause problems in situations where an application expects to be able to hit a URL multiple times (for example, a media player seeking around a video file). This method creates a time-limited URL that can be accessed without any authentication, and returns that to you, along with an expiration time.

Args:
  • path: The file to return a URL for. Folders are not supported.
Returns:

  • A dictionary that looks like the following example:

    {'url': 'https://dl.dropbox.com/0/view/wvxv1fw6on24qw7/file.mov', 'expires': 'Thu, 16 Sep 2011 01:01:25 +0000'}

    For a detailed description of what this call returns, visit: https://www.dropbox.com/developers/reference/api#media

Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: Unable to find the file at the given path.
DropboxClient.metadata(path, list=True, file_limit=25000, hash=None, rev=None, include_deleted=False)

Retrieve metadata for a file or folder.

A typical use would be:

folder_metadata = client.metadata('/')
print "metadata:", folder_metadata

which would return the metadata of the root directory. This will look something like:

{
    'bytes': 0,
    'contents': [
        {
           'bytes': 0,
           'icon': 'folder',
           'is_dir': True,
           'modified': 'Thu, 25 Aug 2011 00:03:15 +0000',
           'path': '/Sample Folder',
           'rev': '803beb471',
           'revision': 8,
           'root': 'dropbox',
           'size': '0 bytes',
           'thumb_exists': False
        }, 
        {
           'bytes': 77,
           'icon': 'page_white_text',
           'is_dir': False,
           'mime_type': 'text/plain',
           'modified': 'Wed, 20 Jul 2011 22:04:50 +0000',
           'path': '/magnum-opus.txt',
           'rev': '362e2029684fe',
           'revision': 221922,
           'root': 'dropbox',
           'size': '77 bytes',
           'thumb_exists': False
        }
    ],
    'hash': 'efdac89c4da886a9cece1927e6c22977',
    'icon': 'folder',
    'is_dir': True,
    'path': '/',
    'root': 'app_folder',
    'size': '0 bytes',
    'thumb_exists': False
}

In this example, the root directory contains two things: Sample Folder, which is a folder, and /magnum-opus.txt, which is a text file 77 bytes long

Args:
  • path: The path to the file or folder.
  • list: Whether to list all contained files (only applies when path refers to a folder).
  • file_limit: The maximum number of file entries to return within a folder. If the number of files in the directory exceeds this limit, an exception is raised. The server will return at max 25,000 files within a folder.
  • hash: Every directory listing has a hash parameter attached that can then be passed back into this function later to save on bandwidth. Rather than returning an unchanged folder’s contents, the server will instead return a 304. - rev: The revision of the file to retrieve the metadata for. [optional] This parameter only applies for files. If omitted, you’ll receive the most recent revision metadata.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 304: Current directory hash matches hash parameters, so contents are unchanged.
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No file was found at given path.
    • 406: Too many file entries to return.
DropboxClient.put_file(full_path, file_obj, overwrite=False, parent_rev=None)

Upload a file.

A typical use case would be as follows:

f = open('working-draft.txt')
response = client.put_file('/magnum-opus.txt', f)
print "uploaded:", response

which would return the metadata of the uploaded file, similar to:

{
    'bytes': 77,
    'icon': 'page_white_text',
    'is_dir': False,
    'mime_type': 'text/plain',
    'modified': 'Wed, 20 Jul 2011 22:04:50 +0000',
    'path': '/magnum-opus.txt',
    'rev': '362e2029684fe',
    'revision': 221922,
    'root': 'dropbox',
    'size': '77 bytes',
    'thumb_exists': False
}
Args:
  • full_path: The full path to upload the file to, including the file name. If the destination directory does not yet exist, it will be created.
  • file_obj: A file-like object to upload. If you would like, you can pass a string as file_obj.
  • overwrite: Whether to overwrite an existing file at the given path. [default False] If overwrite is False and a file already exists there, Dropbox will rename the upload to make sure it doesn’t overwrite anything. You need to check the metadata returned for the new name. This field should only be True if your intent is to potentially clobber changes to a file that you don’t know about.
  • parent_rev: The rev field from the ‘parent’ of this upload. [optional] If your intent is to update the file at the given path, you should pass the parent_rev parameter set to the rev value from the most recent metadata you have of the existing file at that path. If the server has a more recent version of the file at the specified path, it will automatically rename your uploaded file, spinning off a conflict. Using this parameter effectively causes the overwrite parameter to be ignored. The file will always be overwritten if you send the most-recent parent_rev, and it will never be overwritten if you send a less-recent one.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details) - 503: User over quota

Note: In Python versions below version 2.6, httplib doesn’t handle file-like objects. In that case, this code will read the entire file into memory (!).

DropboxClient.request(target, params=None, method='POST', content_server=False)

Make an HTTP request to a target API method.

This is an internal method used to properly craft the url, headers, and params for a Dropbox API request. It is exposed for you in case you need craft other API calls not in this library or if you want to debug it.

Args:

  • target: The target URL with leading slash (e.g. ‘/files’)

  • params: A dictionary of parameters to add to the request

  • method: An HTTP method (e.g. ‘GET’ or ‘POST’)

  • content_server: A boolean indicating whether the request is to the

    API content server, for example to fetch the contents of a file rather than its metadata.

Returns:
  • A tuple of (url, params, headers) that should be used to make the request. OAuth authentication information will be added as needed within these fields.
DropboxClient.restore(path, rev)

Restore a file to a previous revision.

Args:
  • path: The file to restore. Note that folders can’t be restored.
  • rev: A previous rev value of the file to be restored to.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: Unable to find the file at the given revision.
DropboxClient.revisions(path, rev_limit=1000)

Retrieve revisions of a file.

Args:
  • path: The file to fetch revisions for. Note that revisions are not available for folders.
  • rev_limit: The maximum number of file entries to return within a folder. The server will return at max 1,000 revisions.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No revisions were found at the given path.
DropboxClient.search(path, query, file_limit=1000, include_deleted=False)

Search directory for filenames matching query.

Args:
  • path: The directory to search within.
  • query: The query to search on (minimum 3 characters).
  • file_limit: The maximum number of file entries to return within a folder. The server will return at max 1,000 files.
  • include_deleted: Whether to include deleted files in search results.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details)
DropboxClient.share(path)

Create a shareable link to a file or folder.

Shareable links created on Dropbox are time-limited, but don’t require any authentication, so they can be given out freely. The time limit should allow at least a day of shareability, though users have the ability to disable a link from their account if they like.

Args:
  • path: The file or folder to share.
Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: Unable to find the file at the given path.
DropboxClient.thumbnail(from_path, size='large', format='JPEG')

Download a thumbnail for an image.

Unlike most other calls, thumbnail returns a raw HTTPResponse with the connection open. You should call .read() and perform any processing you need, then close the HTTPResponse.

Args:
  • from_path: The path to the file to be thumbnailed.
  • size: A string describing the desired thumbnail size. At this time, ‘small’, ‘medium’, and ‘large’ are officially supported sizes (32x32, 64x64, and 128x128 respectively), though others may be available. Check https://www.dropbox.com/developers/reference/api#thumbnails for more details.
Returns:
  • An httplib.HTTPResponse that is the result of the request.
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of - 400: Bad request (may be due to many things; check e.error for details) - 404: No file was found at the given from_path, or files of that type cannot be thumbnailed. - 415: Image is invalid and cannot be thumbnailed.
DropboxClient.thumbnail_and_metadata(from_path, size='large', format='JPEG')

Download a thumbnail for an image alongwith its metadata.

Acts as a thin wrapper around thumbnail() (see thumbnail() comments for more details)

Args:

  • from_path: The path to the file to be thumbnailed.

  • size: A string describing the desired thumbnail size. See thumbnail()

    for details.

Returns:
Raises:
  • A dropbox.rest.ErrorResponse with an HTTP status of
    • 400: Bad request (may be due to many things; check e.error for details)
    • 404: No file was found at the given from_path, or files of that type cannot be thumbnailed.
    • 415: Image is invalid and cannot be thumbnailed.
    • 200: Request was okay but response was malformed in some way.
DropboxClient.upload_chunk(file_obj, length, offset=0, upload_id=None)

Uploads a single chunk of data from the given file like object. The majority of users should use the ChunkedUploader object, which provides a simpler interface to the chunked_upload API endpoint.

Args:
  • file_obj: The source of the data to upload
  • length: The number of bytes to upload in one chunk.
Returns:
  • The reply from the server, as a dictionary

DropboxSession

dropbox.session.DropboxSession is responsible for holding OAuth authentication info (app key/secret, request key/secret, access key/secret) as well as configuration information for your app (‘app_folder’ or ‘dropbox’ access type, optional locale preference). It knows how to use all of this information to craft properly constructed requests to Dropbox.

A DropboxSession object must be passed to a dropbox.client.DropboxClient object upon initialization.

class dropbox.session.DropboxSession(consumer_key, consumer_secret, access_type, locale=None, rest_client=<class 'dropbox.rest.RESTClient'>)
build_access_headers(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.
build_authorize_url(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.
build_path(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.
build_url(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.
is_linked()

Return whether the DropboxSession has an access token attached.

obtain_access_token(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 tuple of (key, secret) representing the access token Dropbox assigned to this app and user. Also attaches the access token as self.token.
obtain_request_token()

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 dropbox.session.OAuthToken representing the request token Dropbox assigned to this app. Also attaches the request token as self.request_token.
set_request_token(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.

set_token(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.

Remove any attached access token from the DropboxSession.

REST Client

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.

class dropbox.rest.RESTClient
classmethod GET(*n, **kw)

Perform a GET request using RESTClient.request

IMPL = <dropbox.rest.RESTClientObject object at 0x101e4d210>

An 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.

classmethod POST(*n, **kw)

Perform a POST request using RESTClient.request

classmethod PUT(*n, **kw)

Perform a PUT request using RESTClient.request

classmethod request(*n, **kw)

Perform a REST request and parse the response.

Args:
  • 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 in Python 2.6 and above. 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 the raw httplib.HTTPReponse 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 specified, in which case an httplib.HTTPReponse object is returned instead.
Raises:
  • dropbox.rest.ErrorResponse: The returned HTTP status is not 200, or the body was not parsed from JSON successfully.
  • dropbox.rest.RESTSocketError: A socket.error was raised while contacting Dropbox.
class dropbox.rest.ErrorResponse(http_resp)

Raised by dropbox.rest.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 a 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.

class dropbox.rest.RESTSocketError(host, e)

A light wrapper for socket.errors raised by dropbox.rest.RESTClient.request that adds more information to the socket.error.

Table Of Contents

This Page

Navigation

© Copyright 2011, Dropbox, Inc.. Created using Sphinx 1.1.2.