# Destination= os.path.abspath(os.path.join(Parent_Dir, '..'))
except:
CurrentDir = os.getcwd()
Parent_Dir = os.path.abspath(os.path.join(CurrentDir, '..'))
# Destination= os.path.abspath(os.path.join(Parent_Dir, '..'))
CurrentDir = '/tmp'
Destination = os.path.abspath(os.path.join(Parent_Dir, '..'))
# enumerate local files recursively
for root, dirs, files in os.walk(CurrentDir):
for dir2 in dirs:
# if os.path.isdir(Destination+ curent_path+dir2):
try:
client.file_create_folder(remotepath0 + dir2)
except:
pass
for filename in files:
# construct the full local path
local_path = os.path.join(root, filename)
if os.path.isfile(root + "/" + filename):
remotepath = remotepath0
# construct the full Dropbox path
relative_path = os.path.relpath(local_path, CurrentDir)
dropbox_path = os.path.join(remotepath,
relative_path).replace("\\", '/')
# upload the file
link = main_dropbox(app_key, app_secret, access_token,
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
def _client_metadata(self, path):
"""
Get client metadata from cache based on the DROPBOX_CACHE setting.
"""
if DROPBOX_CACHE and isinstance(DROPBOX_CACHE, int):
cache_key = _cache_key(path)
meta = cache.get(cache_key, None)
if not meta:
meta = self.client.metadata(path)
cache.set(cache_key, meta, DROPBOX_CACHE)
return meta
return self.client.metadata(path)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self._client_metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
_clear_cache(abs_name)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
_clear_cache(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self._client_metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self._client_metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
path = os.path.realpath(os.path.join(self.location, name))
return self._client_metadata(path)['bytes']
def url(self, name):
if name.startswith(self.location):
name = name[len(self.location) + 1:]
if self.base_url is None:
raise ValueError("This file is not accessible via a URL.")
return urlparse.urljoin(self.base_url, filepath_to_uri(name))
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
return redirect("/home")
except DropboxOAuth2Flow.ProviderException, e:
return HttpResponse(e.message, status=403)
except Exception, e:
return HttpResponse('Error ' + e.body[u'error_description'] + ' url: ' + url, status=500)
user_profile.dropbox_profile.access_token = { "key" : access_token, "user_id": user_id}
user_profile.is_dropbox_synced = True
user_profile.save()
#Create project folder
api_client = DropboxClient(access_token)
projects = Project.objects.filter(pk__in=user_profile.projects)
for p in projects:
api_client.file_create_folder(settings.APP_NAME + '/' + p.title)
return redirect("/project/{0}/files/".format(request.session['project_id']))
def get_evernote_access_token(request):
if request.method == "GET":
user_profile = UserProfile.objects.get(user = request.user)
access_token = request.GET.get("oauth_token")
oauth_verifier = request.GET.get("oauth_verifier")
token_credentials = urllib2.urlopen("https://sandbox.evernote.com/oauth?oauth_consumer_key=" + settings.EVERNOTE_AUTH_KEY + "&oauth_signature=" + settings.EVERNOTE_AUTH_SECRET +"&oauth_signature_method=PLAINTEXT&oauth_timestamp=1288364369&oauth_nonce=d3d9446802a44259&oauth_token=" + access_token + "&oauth_verifier=" + oauth_verifier).read()
token_credentials = urllib2.unquote(token_credentials)
list_answer = token_credentials.split('&')
if user_profile.evernote_profile is None:
user_profile.evernote_profile = EvernoteProfile()
class DropboxAPI(StorageAPI, AppendOnlyLog):
"dropbox@auth : dropbox.com account with auth info"
def __init__(self):
from params import AUTH_DIR
authdir = AUTH_DIR
self.auth_file = os.path.join(authdir, 'dropbox.auth')
try:
with open(self.auth_file, 'r') as file:
ACCESS_TOKEN = file.readline().rstrip()
USER_ID = file.readline().rstrip()
except IOError:
ACCESS_TOKEN, USER_ID = self._authorize()
self.client = DropboxClient(ACCESS_TOKEN)
def sid(self):
return util.md5("dropbox") % 10000
def copy(self):
return DropboxAPI()
def _authorize(self):
dbg.info('Request access token from Dropbox')
flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
authorize_url = flow.start()
# print 'Open auth url:', authorize_url
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'))
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
# Change to rely on browser
print("We need to authorize access to Dropbox. Please visit the following URL and authorize the access:")
print(authorize_url)
print("")
code = raw_input("Input the code you got: ").strip()
#code = #raw_input("Enter the authorization code here: ").strip()
access_token, user_id = flow.finish(code)
with open(self.auth_file, 'w') as file:
file.write(access_token + "\n")
file.write(user_id + "\n")
dbg.info('Authentication successful')
return (access_token, user_id)
# return: list of file paths
def listdir(self, path):
dic = self.client.metadata(path)
lst = map(lambda x:x["path"], dic["contents"])
lst = map(lambda x:x.split("/")[-1], lst)
return lst
def exists(self, path):
try:
dic = self.client.metadata(path)
if(dic.has_key("is_deleted") and dic["is_deleted"]): return False
return True
except:
return False
def get(self, path):
"""Get the file content
Args:
path: string
Returns:
content: string
"""
conn = self.client.get_file(path)
content = conn.read()
conn.close()
return content
def get_file_rev(self, path, rev):
# get file of a previous version with rev hash_id
content = None
try:
conn = self.client.get_file(path, rev=rev)
content = conn.read()
conn.close()
except ErrorResponse as detail:
#print "[get_file_rev] File doesn't exist", detail
return None
return content
def put(self, path, content):
"""Upload the file
Args:
path: string
content: string, size <= 4MB
Returns: None
"""
from dropbox.rest import ErrorResponse
strobj = StringIO(content)
try:
metadata = self.client.put_file(path, strobj, overwrite=False, autorename=False)
except ErrorResponse as e:
if e.status == 409:
raise ItemAlreadyExists(e.status, e.reason)
else:
raise APIError(e.status, e.reason)
return True
def putdir(self, path):
self.client.file_create_folder(path)
def update(self, path, content):
"""Update the file
Args and returns same as put
"""
strobj = StringIO(content)
metadata = self.client.put_file(path, strobj, overwrite=True)
return True
def rm(self, path):
"""Delete the file
Args:
path: string
"""
self.client.file_delete(path)
def rmdir(self, path):
self.client.file_delete(path)
def metadata(self, path):
# only for file, not dir
_md = self.client.metadata(path)
md = {}
md['size'] = _md['bytes']
md['mtime'] = util.convert_time(_md['modified'])
return md
def delta(self, path=None, cursor=None):
resp = self.client.delta(cursor=cursor, path_prefix=path)
cursor = resp['cursor']
changes = []
for entry in resp['entries']:
event = {}
if entry[1]:
# we don't care about delete event
event['path'] = entry[0]
if entry[1]['is_dir']:
event['type'] = 'folder'
else:
event['type'] = 'file'
changes.append(event)
return cursor, changes
def poll(self, path=None, cursor=None, timeout=30):
# timeout max 480
import requests
import time
from error import PollError
beg_time = time.time()
end_time = beg_time + timeout
curr_time = beg_time
url = 'https://api-notify.dropbox.com/1/longpoll_delta'
params = {}
changes = []
if path:
path = util.format_path(path)
if not cursor:
cursor, _ = self.delta(path)
curr_time = time.time()
while True:
params['cursor'] = cursor
params['timeout'] = max(30, int(end_time - curr_time)) # minimum 30 second
resp = requests.request('GET', url, params=params)
obj = resp.json()
if 'error' in obj:
raise PollError(resp.status_code, resp.text)
if obj['changes']:
cursor, _delta = self.delta(path, cursor)
changes.extend(_delta)
if changes:
break
curr_time = time.time()
if curr_time > end_time:
break
return cursor, changes
def init_log(self, path):
if not self.exists(path):
self.put(path, '')
def reset_log(self, path):
if self.exists(path):
self.rm(path)
def append(self, path, msg):
self.update(path, msg)
def get_logs(self, path, last_clock):
length = 5
# latest revision comes first
revisions = self.client.revisions(path, rev_limit=length)
if not revisions:
return [], None
new_logs = []
new_clock = revisions[0]['rev']
end = False # if reach to end
while True:
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
end = True
break
if end: break
if len(revisions) < length: break
# still have logs unread, double the length
length *= 2
revisions = self.client.revisions(path, rev_limit=length)
# download the content of unseen rev
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
break
if 'is_deleted' in metadata and metadata['is_deleted']: continue
msg = self.get_file_rev(path, metadata['rev'])
if len(msg) > 0:
new_logs.insert(0, msg)
return new_logs, new_clock
def __msg_index(self, fn):
return eval(fn[3:])
def init_log2(self, path):
if not self.exists(path):
self.putdir(path)
def append2(self, path, msg):
path = util.format_path(path)
lst = sorted(self.listdir(path))
if lst:
index = self.__msg_index(lst[-1]) + 1
else:
index = 0
while True:
fn = 'msg%d' % index
fpath = path + '/' + fn
try:
self.put(fpath, msg)
except ItemAlreadyExists:
index += 1
else:
break
def get_logs2(self, path, last_clock):
path = util.format_path(path)
lst = self.listdir(path)
if not lst:
return [], None
srt = {}
for fn in lst:
srt[self.__msg_index(fn)] = fn
lst = [srt[i] for i in sorted(srt.keys(), reverse=True)]
new_logs = []
new_clock = self.__msg_index(lst[0])
for fn in lst:
if last_clock == None and self.__msg_index(fn) == last_clock: break
msg = self.get(path + '/' + fn)
new_logs.insert(0, msg)
return new_logs, new_clock
def share(self, path, target_email):
url = "https://www.dropbox.com/"
print 'Get access token from Dropbox'
print 'Open auth url:', url
browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
browser.get(url)
try:
wait = WebDriverWait(browser, 30)
btn = wait.until(EC.element_to_be_clickable((By.XPATH, "//div[@id='sign-in']/a")))
btn.click()
email = wait.until(EC.element_to_be_clickable((By.XPATH, "//input[@id='login_email']")))
email.send_keys(raw_input("Enter your Dropbox email:"))
pwd = browser.find_element_by_xpath("//input[@id='login_password']")
pwd.send_keys(getpass.getpass("Enter your Dropbox password:"******"//a[text()='%s']" % path)))
target_folder.click()
wait.until(EC.title_contains("%s" % path))
share_btn = browser.find_element_by_xpath("//a[@id='global_share_button']")
share_btn.click()
target = wait.until(EC.element_to_be_clickable((By.XPATH, "//form[@class='invite-more-form']//input[@spellcheck][@type='text']")))
target.send_keys(target_email)
confirm_btn = browser.find_element_by_xpath("//form[@class='invite-more-form']//input[@type='button'][1]")
confirm_btn.click()
except:
print(browser.title)
assert False
# print(browser.current_url)
# print(browser.page_source)
pass
class DropboxAPI(StorageAPI, AppendOnlyLog):
"dropbox@auth : dropbox.com account with auth info"
def __init__(self):
from params import AUTH_DIR
authdir = AUTH_DIR
self.auth_file = os.path.join(authdir, 'dropbox.auth')
try:
with open(self.auth_file, 'r') as file:
ACCESS_TOKEN = file.readline().rstrip()
USER_ID = file.readline().rstrip()
except IOError:
ACCESS_TOKEN, USER_ID = self._authorize()
self.client = DropboxClient(ACCESS_TOKEN)
def sid(self):
return util.md5("dropbox") % 10000
def copy(self):
return DropboxAPI()
def _authorize(self):
dbg.info('Request access token from Dropbox')
flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
authorize_url = flow.start()
# print 'Open auth url:', authorize_url
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'))
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
# Change to rely on browser
print(
"We need to authorize access to Dropbox. Please visit the following URL and authorize the access:"
)
print(authorize_url)
print("")
code = raw_input("Input the code you got: ").strip()
#code = #raw_input("Enter the authorization code here: ").strip()
access_token, user_id = flow.finish(code)
with open(self.auth_file, 'w') as file:
file.write(access_token + "\n")
file.write(user_id + "\n")
dbg.info('Authentication successful')
return (access_token, user_id)
# return: list of file paths
def listdir(self, path):
dic = self.client.metadata(path)
lst = map(lambda x: x["path"], dic["contents"])
lst = map(lambda x: x.split("/")[-1], lst)
return lst
def exists(self, path):
try:
dic = self.client.metadata(path)
if (dic.has_key("is_deleted") and dic["is_deleted"]): return False
return True
except:
return False
def get(self, path):
"""Get the file content
Args:
path: string
Returns:
content: string
"""
conn = self.client.get_file(path)
content = conn.read()
conn.close()
return content
def get_file_rev(self, path, rev):
# get file of a previous version with rev hash_id
content = None
try:
conn = self.client.get_file(path, rev=rev)
content = conn.read()
conn.close()
except ErrorResponse as detail:
#print "[get_file_rev] File doesn't exist", detail
return None
return content
def put(self, path, content):
"""Upload the file
Args:
path: string
content: string, size <= 4MB
Returns: None
"""
from dropbox.rest import ErrorResponse
strobj = StringIO(content)
try:
metadata = self.client.put_file(path,
strobj,
overwrite=False,
autorename=False)
except ErrorResponse as e:
if e.status == 409:
raise ItemAlreadyExists(e.status, e.reason)
else:
raise APIError(e.status, e.reason)
return True
def putdir(self, path):
self.client.file_create_folder(path)
def update(self, path, content):
"""Update the file
Args and returns same as put
"""
strobj = StringIO(content)
metadata = self.client.put_file(path, strobj, overwrite=True)
return True
def rm(self, path):
"""Delete the file
Args:
path: string
"""
self.client.file_delete(path)
def rmdir(self, path):
self.client.file_delete(path)
def metadata(self, path):
# only for file, not dir
_md = self.client.metadata(path)
md = {}
md['size'] = _md['bytes']
md['mtime'] = util.convert_time(_md['modified'])
return md
def delta(self, path=None, cursor=None):
resp = self.client.delta(cursor=cursor, path_prefix=path)
cursor = resp['cursor']
changes = []
for entry in resp['entries']:
event = {}
if entry[1]:
# we don't care about delete event
event['path'] = entry[0]
if entry[1]['is_dir']:
event['type'] = 'folder'
else:
event['type'] = 'file'
changes.append(event)
return cursor, changes
def poll(self, path=None, cursor=None, timeout=30):
# timeout max 480
import requests
import time
from error import PollError
beg_time = time.time()
end_time = beg_time + timeout
curr_time = beg_time
url = 'https://api-notify.dropbox.com/1/longpoll_delta'
params = {}
changes = []
if path:
path = util.format_path(path)
if not cursor:
cursor, _ = self.delta(path)
curr_time = time.time()
while True:
params['cursor'] = cursor
params['timeout'] = max(30, int(end_time -
curr_time)) # minimum 30 second
resp = requests.request('GET', url, params=params)
obj = resp.json()
if 'error' in obj:
raise PollError(resp.status_code, resp.text)
if obj['changes']:
cursor, _delta = self.delta(path, cursor)
changes.extend(_delta)
if changes:
break
curr_time = time.time()
if curr_time > end_time:
break
return cursor, changes
def init_log(self, path):
if not self.exists(path):
self.put(path, '')
def reset_log(self, path):
if self.exists(path):
self.rm(path)
def append(self, path, msg):
self.update(path, msg)
def get_logs(self, path, last_clock):
length = 5
# latest revision comes first
revisions = self.client.revisions(path, rev_limit=length)
if not revisions:
return [], None
new_logs = []
new_clock = revisions[0]['rev']
end = False # if reach to end
while True:
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
end = True
break
if end: break
if len(revisions) < length: break
# still have logs unread, double the length
length *= 2
revisions = self.client.revisions(path, rev_limit=length)
# download the content of unseen rev
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
break
if 'is_deleted' in metadata and metadata['is_deleted']: continue
msg = self.get_file_rev(path, metadata['rev'])
if len(msg) > 0:
new_logs.insert(0, msg)
return new_logs, new_clock
def __msg_index(self, fn):
return eval(fn[3:])
def init_log2(self, path):
if not self.exists(path):
self.putdir(path)
def append2(self, path, msg):
path = util.format_path(path)
lst = sorted(self.listdir(path))
if lst:
index = self.__msg_index(lst[-1]) + 1
else:
index = 0
while True:
fn = 'msg%d' % index
fpath = path + '/' + fn
try:
self.put(fpath, msg)
except ItemAlreadyExists:
index += 1
else:
break
def get_logs2(self, path, last_clock):
path = util.format_path(path)
lst = self.listdir(path)
if not lst:
return [], None
srt = {}
for fn in lst:
srt[self.__msg_index(fn)] = fn
lst = [srt[i] for i in sorted(srt.keys(), reverse=True)]
new_logs = []
new_clock = self.__msg_index(lst[0])
for fn in lst:
if last_clock == None and self.__msg_index(fn) == last_clock: break
msg = self.get(path + '/' + fn)
new_logs.insert(0, msg)
return new_logs, new_clock
def share(self, path, target_email):
url = "https://www.dropbox.com/"
print 'Get access token from Dropbox'
print 'Open auth url:', url
browser = webdriver.PhantomJS(
service_log_path=os.path.join(tempfile.gettempdir(),
'ghostdriver.log'),
service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
browser.get(url)
try:
wait = WebDriverWait(browser, 30)
btn = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//div[@id='sign-in']/a")))
btn.click()
email = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//input[@id='login_email']")))
email.send_keys(raw_input("Enter your Dropbox email:"))
pwd = browser.find_element_by_xpath(
"//input[@id='login_password']")
pwd.send_keys(getpass.getpass("Enter your Dropbox password:"******"//a[text()='%s']" % path)))
target_folder.click()
wait.until(EC.title_contains("%s" % path))
share_btn = browser.find_element_by_xpath(
"//a[@id='global_share_button']")
share_btn.click()
target = wait.until(
EC.element_to_be_clickable((
By.XPATH,
"//form[@class='invite-more-form']//input[@spellcheck][@type='text']"
)))
target.send_keys(target_email)
confirm_btn = browser.find_element_by_xpath(
"//form[@class='invite-more-form']//input[@type='button'][1]")
confirm_btn.click()
except:
print(browser.title)
assert False
# print(browser.current_url)
# print(browser.page_source)
pass
class cloudfiles_nb(object):
def __init__(self, api_type, keys):
self.api_type = api_type
if api_type == 'aws':
from boto.s3.connection import S3Connection
aws_key, aws_secret = keys
self.conn = S3Connection(aws_key, aws_secret)
elif api_type == 'dropbox':
from dropbox.client import DropboxClient
from dropbox.session import DropboxSession
access_token = keys
self.uploaded_files = {}
self.client = DropboxClient(access_token)
self.base_dir = 'workdocs-cloudfiles'
self.folders_list = [p['path'].replace('/%s/' %self.base_dir, '')\
for p in self.client.metadata(self.base_dir)['contents']]
self.upload_file_res = {}
def initialize_folder(self, folder_name):
if self.api_type == 'aws':
self.bucket = self.conn.create_bucket(folder_name)
self.folder_name = folder_name
elif self.api_type == 'dropbox':
self.thisfolder = '%s/%s' % (self.base_dir, folder_name)
if folder_name in self.folders_list:
print 'folder already exists'
res = None
else:
print 'creating folder'
res = self.client.file_create_folder(self.thisfolder)
# do something for error
return res
def upload_file(self, filepath):
if self.api_type == 'aws':
from boto.s3.key import Key
filename = filepath.split('/')[-1]
k = Key(self.bucket)
k.key = filename
k.set_contents_from_filename(filepath)
k.set_acl('public-read')
if '.png' in k.key: k.set_metadata('Contet-Type', 'image/png')
elif self.api_type == 'dropbox':
f = open(filepath, 'r')
filename = filepath.split('/')[-1]
newfile = '%s/%s' % (self.thisfolder, filename)
# if filename alread exists, delate and replace
#filecheck = self.client.search(self.thisfolder, filename)
#if filecheck: del_res = self.client.file_delete(newfile)
res = self.client.put_file(newfile, f, overwrite=True)
return res
def get_file_link(self, filename):
if self.api_type == 'aws':
thiskey = self.bucket.get_key(filename)
res = 'https://%s.s3.amazonaws.com/%s' % (self.bucket.name,
filename)
# something for error
return res
elif self.api_type == 'dropbox':
res = self.client.media('%s/%s' %
(self.thisfolder, filename))['url']
# something for error
return res
def get_nbviewer_link(self, filename):
file_link = self.get_file_link(filename)
nbv_pfx = 'http://nbviewer.ipython.org/urls'
res = nbv_pfx + '/' + file_link.replace('https://', '')
return res
def get_slideviewer_link(self, filename):
file_link = self.get_file_link(filename)
sv_pfx = 'https://slideviewer.herokuapp.com/urls'
res = sv_pfx + '/' + file_link.replace('https://', '')
return res
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY,
CONSUMER_SECRET,
ACCESS_TYPE,
locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(
**self.account_info)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self.client.metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self.client.metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self.client.metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name)
size = cache.get(cache_key)
if not size:
size = self.client.metadata(filepath_to_uri(name))['bytes']
cache.set(cache_key, size, CACHE_TIMEOUT)
return size
def url(self, name):
cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name)
url = cache.get(cache_key)
if not url:
url = self.client.share(filepath_to_uri(name),
short_url=False)['url'] + '?dl=1'
cache.set(cache_key, url, CACHE_TIMEOUT)
return url
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(
dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self.client.metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self.client.metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self.client.metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name)
size = cache.get(cache_key)
if not size:
size = self.client.metadata(filepath_to_uri(name))['bytes']
cache.set(cache_key, size, CACHE_TIMEOUT)
return size
def url(self, name):
cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name)
url = cache.get(cache_key)
if not url:
url = self.client.share(filepath_to_uri(name), short_url=False)['url'] + '?dl=1'
cache.set(cache_key, url, CACHE_TIMEOUT)
return url
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
Parent_Dir=os.path.abspath(os.path.join(CurrentDir, '..'))
# Destination= os.path.abspath(os.path.join(Parent_Dir, '..'))
except:
CurrentDir=os.getcwd()
Parent_Dir=os.path.abspath(os.path.join(CurrentDir, '..'))
# Destination= os.path.abspath(os.path.join(Parent_Dir, '..'))
CurrentDir='/tmp'
Destination= os.path.abspath(os.path.join(Parent_Dir, '..'))
# enumerate local files recursively
for root, dirs, files in os.walk(CurrentDir):
for dir2 in dirs:
# if os.path.isdir(Destination+ curent_path+dir2):
try:client.file_create_folder(remotepath0+dir2)
except:pass
for filename in files:
# construct the full local path
local_path = os.path.join(root, filename)
if os.path.isfile(root+"/"+filename):
remotepath=remotepath0
# construct the full Dropbox path
relative_path = os.path.relpath(local_path, CurrentDir)
dropbox_path = os.path.join(remotepath, relative_path).replace("\\",'/')
# upload the file
link=main_dropbox(app_key,app_secret,access_token,local_path,dropbox_path).main_dropbox(local_path,dropbox_path)
# with open(local_path, 'rb') as f:
# client.put_file(dropbox_path, f)
def createnewfolder(uid):
access_token = redis_client.hget('tokens', uid)
client = DropboxClient(access_token)
newfolder = client.file_create_folder('APITestFolder2')
return str(newfolder)
def createnewfolder(uid):
access_token = redis_client.hget('tokens', uid)
client = DropboxClient(access_token)
newfolder = client.file_create_folder('APITestFolder2')
return str(newfolder)
class cloudfiles_nb(object):
def __init__(self, api_type, keys):
self.api_type = api_type
if api_type == "aws":
from boto.s3.connection import S3Connection
aws_key, aws_secret = keys
self.conn = S3Connection(aws_key, aws_secret)
elif api_type == "dropbox":
from dropbox.client import DropboxClient
from dropbox.session import DropboxSession
access_token = keys
self.uploaded_files = {}
self.client = DropboxClient(access_token)
self.base_dir = "workdocs-cloudfiles"
self.folders_list = [
p["path"].replace("/%s/" % self.base_dir, "") for p in self.client.metadata(self.base_dir)["contents"]
]
self.upload_file_res = {}
def initialize_folder(self, folder_name):
if self.api_type == "aws":
self.bucket = self.conn.create_bucket(folder_name)
self.folder_name = folder_name
elif self.api_type == "dropbox":
self.thisfolder = "%s/%s" % (self.base_dir, folder_name)
if folder_name in self.folders_list:
print "folder already exists"
res = None
else:
print "creating folder"
res = self.client.file_create_folder(self.thisfolder)
# do something for error
return res
def upload_file(self, filepath):
if self.api_type == "aws":
from boto.s3.key import Key
filename = filepath.split("/")[-1]
k = Key(self.bucket)
k.key = filename
k.set_contents_from_filename(filepath)
k.set_acl("public-read")
if ".png" in k.key:
k.set_metadata("Contet-Type", "image/png")
elif self.api_type == "dropbox":
f = open(filepath, "r")
filename = filepath.split("/")[-1]
newfile = "%s/%s" % (self.thisfolder, filename)
# if filename alread exists, delate and replace
# filecheck = self.client.search(self.thisfolder, filename)
# if filecheck: del_res = self.client.file_delete(newfile)
res = self.client.put_file(newfile, f, overwrite=True)
return res
def get_file_link(self, filename):
if self.api_type == "aws":
thiskey = self.bucket.get_key(filename)
res = "https://%s.s3.amazonaws.com/%s" % (self.bucket.name, filename)
# something for error
return res
elif self.api_type == "dropbox":
res = self.client.media("%s/%s" % (self.thisfolder, filename))["url"]
# something for error
return res
def get_nbviewer_link(self, filename):
file_link = self.get_file_link(filename)
nbv_pfx = "http://nbviewer.ipython.org/urls"
res = nbv_pfx + "/" + file_link.replace("https://", "")
return res
def get_slideviewer_link(self, filename):
file_link = self.get_file_link(filename)
sv_pfx = "https://slideviewer.herokuapp.com/urls"
res = sv_pfx + "/" + file_link.replace("https://", "")
return res
class DropBox(clouddrive.CloudDrive):
name = "DropBox"
def __init__(self, access_token):
self.client = DropboxClient(access_token)
self.access_token = access_token
clouddrive.CloudDrive.__init__(self, access_token)
@staticmethod
def auth():
#app_key = 'knbyx2adg14kkn5'
#app_secret = 'kh3ulgqry8jffqp'
app_key = 'eif0l7bgnpb06di'
app_secret = 'qa02jhdo4jrwaid'
global Auth_DROPMytoken
global Auth_Drop_Running_true
def keep_running():
global Auth_Drop_Running_true
return Auth_Drop_Running_true
class AuthHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
if s.path.find("code=") != -1:
global Auth_DROPMytoken
global Auth_Drop_Running_true
Auth_DROPMytoken = s.path
Auth_Drop_Running_true = False
s.wfile.write("ok see command line")
return
class MYrequest:
def __init__(self, url):
self.url = url
def get(self, mystring):
if self.url.find(mystring) == -1:
return
item = self.url.split(mystring + "=")[1]
if item.find("&") != -1:
item = item.split("&")[0]
return urllib.unquote(item).decode()
redirect_url = "http://localhost:8787"
my_session = {}
Auth_Drop_Running_true = True
flow = DropboxOAuth2Flow(app_key, app_secret, redirect_url, my_session,
"dropbox-auth-csrf-token")
authorize_url = flow.start()
webbrowser.open(authorize_url)
try:
httpd = BaseHTTPServer.HTTPServer(("", 8787), AuthHandler)
while keep_running():
httpd.handle_request()
except KeyboardInterrupt:
pass
httpd.server_close()
token, user_id, url_state = flow.finish(MYrequest(Auth_DROPMytoken))
clouddrive.CloudDrive.access_token = token
return token
def read(self, filename):
try:
data = []
with self.client.get_file(filename) as f:
data += f.read()
except:
return -1
return ''.join(data)
def write(self, filename, data):
try:
response = self.client.put_file(filename, data, True)
except:
return -1
return 1
def mkdir(self, dirname):
try:
self.client.file_create_folder(dirname)
except:
return -1
return 1
def delete(self, filename):
try:
self.client.file_delete(filename)
except:
return -1
return 1
def capacity(self):
try:
a = self.client.account_info()["quota_info"]
except:
return -1
return a["quota"] - a["shared"] - a["normal"]
def listing(self, path="/"):
lists = self.client.metadata(path)
filelist = []
for x in lists["contents"]:
filelist.append((x['path'], x['is_dir']))
return filelist
class DropBox(clouddrive.CloudDrive):
name = "DropBox"
def __init__(self, access_token):
self.client = DropboxClient(access_token)
self.access_token = access_token
clouddrive.CloudDrive.__init__(self, access_token)
@staticmethod
def auth():
#app_key = 'knbyx2adg14kkn5'
#app_secret = 'kh3ulgqry8jffqp'
app_key = 'eif0l7bgnpb06di'
app_secret = 'qa02jhdo4jrwaid'
global Auth_DROPMytoken
global Auth_Drop_Running_true
def keep_running():
global Auth_Drop_Running_true
return Auth_Drop_Running_true
class AuthHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
if s.path.find("code=") != -1:
global Auth_DROPMytoken
global Auth_Drop_Running_true
Auth_DROPMytoken = s.path
Auth_Drop_Running_true = False
s.wfile.write("ok see command line")
return
class MYrequest:
def __init__(self, url):
self.url = url
def get(self, mystring):
if self.url.find(mystring) == -1:
return
item = self.url.split(mystring + "=")[1]
if item.find("&") != -1:
item = item.split("&")[0]
return urllib.unquote(item).decode()
redirect_url = "http://localhost:8787"
my_session = {}
Auth_Drop_Running_true = True
flow = DropboxOAuth2Flow(app_key, app_secret, redirect_url, my_session, "dropbox-auth-csrf-token")
authorize_url = flow.start()
webbrowser.open(authorize_url)
try:
httpd = BaseHTTPServer.HTTPServer(("", 8787), AuthHandler)
while keep_running():
httpd.handle_request()
except KeyboardInterrupt:
pass
httpd.server_close()
token, user_id, url_state = flow.finish(MYrequest(Auth_DROPMytoken))
clouddrive.CloudDrive.access_token = token
return token
def read(self, filename):
try:
data=[]
with self.client.get_file(filename) as f:
data+=f.read()
except:
return -1
return ''.join(data)
def write(self, filename, data):
try:
response = self.client.put_file(filename, data,True)
except:
return -1
return 1
def mkdir(self, dirname):
try:
self.client.file_create_folder(dirname)
except:
return -1
return 1
def delete(self, filename):
try:
self.client.file_delete(filename)
except:
return -1
return 1
def capacity(self):
try:
a=self.client.account_info()["quota_info"]
except:
return -1
return a["quota"]-a["shared"]-a["normal"]
def listing (self, path="/") :
lists=self.client.metadata(path)
filelist=[]
for x in lists["contents"] :
filelist.append((x['path'],x['is_dir']))
return filelist
