Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
pyrax_identity	[ DIR ]	drwxr-xr-x
adbackend.py	16.98 KB	-rw-r--r--
azurebackend.py	5.47 KB	-rw-r--r--
b2backend.py	8.82 KB	-rw-r--r--
_boto_multi.py	9.72 KB	-rw-r--r--
_boto_single.py	14.65 KB	-rw-r--r--
boxbackend.py	6.99 KB	-rw-r--r--
cfbackend.py	1.13 KB	-rw-r--r--
_cf_cloudfiles.py	3.85 KB	-rw-r--r--
_cf_pyrax.py	5.12 KB	-rw-r--r--
dpbxbackend.py	19.93 KB	-rw-r--r--
gdocsbackend.py	9.17 KB	-rw-r--r--
gdrivebackend.py	15.45 KB	-rw-r--r--
giobackend.py	8.05 KB	-rw-r--r--
hsibackend.py	2.67 KB	-rw-r--r--
hubicbackend.py	2.38 KB	-rw-r--r--
idrivedbackend.py	19.08 KB	-rw-r--r--
imapbackend.py	9.96 KB	-rw-r--r--
__init__.py	1.09 KB	-rw-r--r--
jottacloudbackend.py	5.54 KB	-rw-r--r--
lftpbackend.py	9.79 KB	-rw-r--r--
localbackend.py	2.96 KB	-rw-r--r--
mediafirebackend.py	4.71 KB	-rw-r--r--
megabackend.py	6.73 KB	-rw-r--r--
megav2backend.py	8.63 KB	-rw-r--r--
megav3backend.py	10.11 KB	-rw-r--r--
multibackend.py	15.49 KB	-rw-r--r--
ncftpbackend.py	5.58 KB	-rw-r--r--
onedrivebackend.py	15.03 KB	-rw-r--r--
par2backend.py	9.06 KB	-rw-r--r--
pcabackend.py	12.36 KB	-rw-r--r--
pydrivebackend.py	13.08 KB	-rw-r--r--
rclonebackend.py	4.22 KB	-rw-r--r--
README	2.52 KB	-rw-r--r--
rsyncbackend.py	6.51 KB	-rw-r--r--
s3_boto3_backend.py	9.41 KB	-rw-r--r--
s3_boto_backend.py	1.5 KB	-rw-r--r--
ssh_paramiko_backend.py	19.86 KB	-rw-r--r--
ssh_pexpect_backend.py	12.92 KB	-rw-r--r--
swiftbackend.py	10.04 KB	-rw-r--r--
sxbackend.py	2.31 KB	-rw-r--r--
tahoebackend.py	2.58 KB	-rw-r--r--
webdavbackend.py	19.77 KB	-rw-r--r--

Code Editor : gdocsbackend.py

# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4; encoding:utf8 -*-
#
# Copyright 2011 Carlos Abalde <carlos.abalde@gmail.com>
#
# This file is part of duplicity.
#
# Duplicity is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# Duplicity is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with duplicity; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

from __future__ import print_function
from future import standard_library
standard_library.install_aliases()
from builtins import input
from builtins import str
import os.path
import string
import urllib.request  # pylint: disable=import-error
import urllib.parse  # pylint: disable=import-error
import urllib.error  # pylint: disable=import-error

import duplicity.backend
from duplicity import __version__
from duplicity.errors import BackendException

class GDocsBackend(duplicity.backend.Backend):
    u"""Connect to remote store using Google Google Documents List API"""

ROOT_FOLDER_ID = u'folder%3Aroot'
    BACKUP_DOCUMENT_TYPE = u'application/binary'

def __init__(self, parsed_url):
        duplicity.backend.Backend.__init__(self, parsed_url)

# Import Google Data APIs libraries.
        try:
            global atom
            global gdata
            import atom.data
            import gdata.client
            import gdata.docs.client
            import gdata.docs.data
        except ImportError as e:
            raise BackendException(u"""\
Google Docs backend requires Google Data APIs Python Client Library (see http://code.google.com/p/gdata-python-client/).
Exception: %s""" % str(e))

# Setup client instance.
        self.client = gdata.docs.client.DocsClient(source=u'duplicity %s' % __version__)
        self.client.ssl = True
        self.client.http_client.debug = False
        self._authorize(parsed_url.username + u'@' + parsed_url.hostname, self.get_password())

# Fetch destination folder entry (and crete hierarchy if required).
        folder_names = string.split(parsed_url.path[1:], u'/')
        parent_folder = None
        parent_folder_id = GDocsBackend.ROOT_FOLDER_ID
        for folder_name in folder_names:
            entries = self._fetch_entries(parent_folder_id, u'folder', folder_name)
            if entries is not None:
                if len(entries) == 1:
                    parent_folder = entries[0]
                elif len(entries) == 0:
                    folder = gdata.docs.data.Resource(type=u'folder', title=folder_name)
                    parent_folder = self.client.create_resource(folder, collection=parent_folder)
                else:
                    parent_folder = None
                if parent_folder:
                    parent_folder_id = parent_folder.resource_id.text
                else:
                    raise BackendException(u"Error while creating destination folder '%s'." % folder_name)
            else:
                raise BackendException(u"Error while fetching destination folder '%s'." % folder_name)
        self.folder = parent_folder

def _put(self, source_path, remote_filename):
        self._delete(remote_filename)

# Set uploader instance. Note that resumable uploads are required in order to
        # enable uploads for all file types.
        # (see http://googleappsdeveloper.blogspot.com/2011/05/upload-all-file-types-to-any-google.html)
        file = source_path.open()
        uploader = gdata.client.ResumableUploader(
            self.client, file,
            GDocsBackend.BACKUP_DOCUMENT_TYPE,
            os.path.getsize(file.name),
            chunk_size=gdata.client.ResumableUploader.DEFAULT_CHUNK_SIZE,
            desired_class=gdata.docs.data.Resource)
        if uploader:
            # Chunked upload.
            entry = gdata.docs.data.Resource(title=atom.data.Title(text=remote_filename))
            uri = self.folder.get_resumable_create_media_link().href + u'?convert=false'
            entry = uploader.UploadFile(uri, entry=entry)
            if not entry:
                raise BackendException(u"Failed to upload file '%s' to remote folder '%s'"
                                       % (source_path.get_filename(), self.folder.title.text))
        else:
            raise BackendException(u"Failed to initialize upload of file '%s' to remote folder '%s'"
                                   % (source_path.get_filename(), self.folder.title.text))
        assert not file.close()

def _get(self, remote_filename, local_path):
        entries = self._fetch_entries(self.folder.resource_id.text,
                                      GDocsBackend.BACKUP_DOCUMENT_TYPE,
                                      remote_filename)
        if len(entries) == 1:
            entry = entries[0]
            self.client.DownloadResource(entry, local_path.name)
        else:
            raise BackendException(u"Failed to find file '%s' in remote folder '%s'"
                                   % (remote_filename, self.folder.title.text))

def _list(self):
        entries = self._fetch_entries(self.folder.resource_id.text,
                                      GDocsBackend.BACKUP_DOCUMENT_TYPE)
        return [entry.title.text for entry in entries]

def _delete(self, filename):
        entries = self._fetch_entries(self.folder.resource_id.text,
                                      GDocsBackend.BACKUP_DOCUMENT_TYPE,
                                      filename)
        for entry in entries:
            self.client.delete(entry.get_edit_link().href + u'?delete=true', force=True)

def _authorize(self, email, password, captcha_token=None, captcha_response=None):
        try:
            self.client.client_login(email,
                                     password,
                                     source=u'duplicity %s' % __version__,
                                     service=u'writely',
                                     captcha_token=captcha_token,
                                     captcha_response=captcha_response)
        except gdata.client.CaptchaChallenge as challenge:
            print(u'A captcha challenge in required. Please visit ' + challenge.captcha_url)
            answer = None
            while not answer:
                answer = eval(input(u'Answer to the challenge? '))
            self._authorize(email, password, challenge.captcha_token, answer)
        except gdata.client.BadAuthentication:
            raise BackendException(
                u'Invalid user credentials given. Be aware that accounts '
                u'that use 2-step verification require creating an application specific '
                u'access code for using this Duplicity backend. Follow the instruction in '
                u'http://www.google.com/support/accounts/bin/static.py?page=guide.cs&guide=1056283&topic=1056286 '
                u'and create your application-specific password to run duplicity backups.')

def _fetch_entries(self, folder_id, type, title=None):  # pylint: disable=redefined-builtin
        # Build URI.
        uri = u'/feeds/default/private/full/%s/contents' % folder_id
        if type == u'folder':
            uri += u'/-/folder?showfolders=true'
        elif type == GDocsBackend.BACKUP_DOCUMENT_TYPE:
            uri += u'?showfolders=false'
        else:
            uri += u'?showfolders=true'
        if title:
            uri += u'&title=' + urllib.parse.quote(title) + u'&title-exact=true'

# Fetch entries.
        entries = self.client.get_all_resources(uri=uri)

# When filtering by entry title, API is returning (don't know why) documents in other
        # folders (apart from folder_id) matching the title, so some extra filtering is required.
        if title:
            result = []
            for entry in entries:
                resource_type = entry.get_resource_type()
                if (not type) \
                   or (type == u'folder' and resource_type == u'folder') \
                   or (type == GDocsBackend.BACKUP_DOCUMENT_TYPE and resource_type != u'folder'):

if folder_id != GDocsBackend.ROOT_FOLDER_ID:
                        for link in entry.in_collections():
                            folder_entry = self.client.get_entry(link.href, None, None,
                                                                 desired_class=gdata.docs.data.Resource)
                            if folder_entry and (folder_entry.resource_id.text == folder_id):
                                result.append(entry)
                    elif len(entry.in_collections()) == 0:
                        result.append(entry)
        else:
            result = entries

# Done!
        return result

u""" gdata is an alternate way to access gdocs, currently 05/2015 lacking OAuth support """
duplicity.backend.register_backend(u'gdata+gdocs', GDocsBackend)
duplicity.backend.uses_netloc.extend([u'gdata+gdocs'])

${this.title}

Code Editor : gdocsbackend.py