def list_folder (root_folder_name):
f.write ("Traversing " + root_folder_name + '\n');
folder_metadata = client.metadata(root_folder_name, list=True, include_deleted=True)
for file_name in folder_metadata['contents']:
if (file_name['is_dir']):
list_folder(file_name['path'])
else:
file_mod = parser.parse(file_name['modified'])
if file_name.get('is_deleted', False): # file has been deleted
if (file_mod >= cutoff_bottom) and (file_mod <= cutoff_top): # and only recently
#Now look for the PREVIOUS version
revisions = client.revisions(file_name['path'], 100);
#print "Found " + str(len(revisions)) + " revisions: \n";
revisions.reverse();
revisions.pop() # ignore the latest, this is the deleted version
myrev = revisions.pop();
f.write("Recovering " + file_name['path'] + "(" + myrev['modified'] + ", rev " + str(myrev['rev']) + '\n');
result = client.restore(file_name['path'], myrev['rev']);
print "Restored " + file_name['path'] + ". (" + myrev['modified'] + ", " + str(result['size']) + ")";
else:
f.write("Not recovering " + file_name['path'] + ' rev ' + file_name['rev'] + '\n');
return;
def app_list(request):
client = db_client(request)
if not client:
return redirect(dropbox_auth)
folder_metadata = client.metadata('/')
folder_names = [metadata["path"][1:] for metadata in folder_metadata["contents"] if metadata["is_dir"]]
return render(request, "app_list.html", {"apps": folder_names})
def dropbox_ls():
dropbox_access_token = session.get(DROPBOX_ACCESS_KEY, None)
if dropbox_access_token is None:
return "please log into dropbox first"
root = request.args.get('dir', '/')
dropbox_client = get_client(dropbox_access_token)
try:
resp = dropbox_client.metadata(root)
if 'contents' in resp:
results = list()
for f in resp['contents']:
result = dict()
result['name'] = os.path.basename(f['path'])
result['path'] = f['path']
result['isDirectory'] = False
result['isFile'] = True
if f['is_dir']:
result['isDirectory'] = True
result['isFile'] = False
results.append(result)
return json.dumps(results)
else:
return "malformed response from dropbox:\n %s" % str(resp)
except Exception, e:
return e.message
def app_list(request):
client = db_client(request)
if not client:
return redirect(dropbox_auth)
folder_metadata = client.metadata('/')
folder_names = [
metadata["path"][1:] for metadata in folder_metadata["contents"]
if metadata["is_dir"]
]
return render(request, "app_list.html", {"apps": folder_names})
def collect_files(path, client, result):
"""Recursively collect files in path and it's subfolders using an Dropbox client"""
files = client.metadata(path)['contents']
print files
for f in files:
if f['is_dir']:
collect_files(f['path'], client, result)
else:
result.append(f)
return result
def get_metadata(access_token,d):
"""Returns a metadata listing on directory/file"""
resp = {}
message = ''
try:
client = get_client(access_token)
resp = client.metadata(d)
except rest.ErrorResponse as e:
message = str(e)
return (resp,message)
def recover_tree(folder="/", recover_to=recover_to):
# called recursively. We're going to walk the entire Dropbox
# file tree, starting at 'folder', files first, and recover anything
# deleted in the last 5 days.
print "walking in %s" % folder
try:
meta = client.metadata(folder, include_deleted=True, file_limit=10000)
except rest.ErrorResponse, e:
print e # normally "too many files". Dropbox will only list 10000 files in
# a folder. THere is probably a way around this, but I haven't needed it yet.
return
def get_directory(client, current_path = "/"):
list = client.metadata(current_path, list=True, file_limit=10000, hash=None, rev=None, include_deleted=False)
info = []
for content in list['contents']:
path = content['path'].split(current_path)[1:]
path = ''.join(path)
is_dir = content['is_dir']
insert = {'path' : path, 'is_dir' : is_dir}
info.append(insert)
info = sorted(info, key = itemgetter('is_dir'), reverse=True) # sort by type
data = {'directory' : info, 'current_path' : current_path}
return data
def process_folder(path):
print 'process folder', path.encode('ascii', 'replace')
folder_metadata = client.metadata(path, include_deleted=True)
for meta in folder_metadata['contents']:
if meta['is_dir']:
process_folder(meta['path'])
elif meta.has_key('is_deleted') and meta['is_deleted']:
f = meta['path']
print 'restore file', f.encode('ascii', 'replace')
revs = client.revisions(f, rev_limit=2)
if len(revs) >= 2:
client.restore(f, revs[1]['rev'])
def check_status(job):
"""
Checks the status of a job, returns metadata if complete, False otherwise.
"""
client = get_dropbox_client()
try:
return client.metadata(
'/Video Automation Platform/jobs/{job}/{job}.png'.format(job=job))
except ErrorResponse:
return False
def recover_tree(folder = "/", recover_to=recover_to):
# called recursively. We're going to walk the entire Dropbox
# file tree, starting at 'folder', files first, and recover anything
# deleted in the last 5 days.
print "walking in %s"%folder
try:
meta = client.metadata(folder, include_deleted=True, file_limit=10000)
except rest.ErrorResponse, e:
print e # normally "too many files". Dropbox will only list 10000 files in
# a folder. THere is probably a way around this, but I haven't needed it yet.
return
def posts(self,page=1):
if(self.session.needs_authentication()):
raise cherrypy.HTTPRedirect(self.session.get_auth_url('/set_dropbox_auth'))
client = self.session.get_client()
posts = []
contents = sorted(client.metadata('/')['contents'], key=lambda post: parse(post['client_mtime']), reverse=True)
startIdx = (int(page)-1) * 10
for f in contents[startIdx:startIdx+10]:
if(f['path'].endswith('.md')):
posts.append(self.generator.generate_post(f['path']))
num_posts = len(contents)
are_more_posts = (int(page) * 10) < num_posts
template = Template(filename='index.html')
return template.render(posts=posts, is_index=True, is_post=False, are_more_posts=are_more_posts, page=int(page), analytics=analytics )
def retrieve_images(self):
"""list files in remote directory"""
dropbox_client = self.get_client()
#resp = client.metadata(self.current_path)
path = dropbox_client.metadata(path='https://www.dropbox.com/')
#path='https://dl.dropbox.com/sh/1294vo0qreb8iad/tZIay8d54h'
meta = client.metadata(path)
filelist = []
for item in meta['contents']:
if item['is_dir']:
filelist += self._listfiles(client,item['path'])
else:
filelist.append(item['path'])
return filelist
def download(self,file,options):
'''Plugin interface method to download a file and create a new dataset
:param file: Path to the remote file to download
:type file: str
:param options: context parameters
:type options: list
:return: tmp file path
'''
from dropbox import client
self.sess.set_token(options['drop_access_token'].key,options['drop_access_token'].secret)
client = client.DropboxClient(self.sess)
logging.warn("DropBox - download request for "+file)
folder_metadata = client.metadata('/')
logging.warn("/ content "+str(folder_metadata))
f, metadata = client.get_file_and_metadata(file)
(out,file_path) = tempfile.mkstemp()
output_file = open(file_path, 'wb')
output_file.write(f.read())
return file_path
def main():
# 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()
# Make the user sign in and authorize this token
url = sess.build_authorize_url(request_token)
print "url:", url
print "Please authorize in the browser. After you're done, press enter."
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()
f = open('working-draft.txt')
response = client.put_file('/magnum-opus.txt', f)
print "uploaded:", response
folder_metadata = client.metadata('/')
print "metadata:", folder_metadata
f, metadata = client.get_file_and_metadata('/magnum-opus.txt')
out = open('magnum-opus.txt', 'w')
out.write(f.read())
out.close()
print(metadata)
def list_files(src):
response = client.metadata(src)
#print "Response:\n" + response
return response
# Include the Dropbox SDK libraries
from dropbox import client, rest, session
import os
# Get your app key and secret from the Dropbox developer website
APP_KEY = 'e6lpdx1vtw8bc0p'
APP_SECRET = 'dg30b9zm1biajh3'
# ACCESS_TYPE should be 'dropbox' or 'app_folder' as configured for your app
ACCESS_TYPE = 'app_folder'
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)
import simplejson as json
with open('token','r')as f:
access_token = json.load(f, encoding='utf-8')
sess.set_token(access_token["key"].encode(), access_token[u"secret"].encode())
client = client.DropboxClient(sess)
#print "linked account:", client.account_info()
# folder metadata
folder_metadata = client.metadata('/')
#print "metadata:", folder_metadata
for content in folder_metadata["contents"]:
print "%s(%d)" % (content["path"], int(content["bytes"]))
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)
request_token = sess.obtain_request_token()
url = sess.build_authorize_url(request_token)
print url
raw_input()
access_token = sess.obtain_access_token(request_token)
client = client.DropboxClient(sess)
print "linked account:"
pprint(client.account_info())
folder_metadata = client.metadata('/')
print "metadata:"
pprint(folder_metadata)
if folder_metadata['is_dir'] == True:
print "isdir"
else:
print "ko"
for folder in map(lambda n : n['path'][1:] , client.metadata('/')['contents']):
print folder
def request_cat_media_links():
files = client.metadata("/")["contents"] # Get all the files in cat folder
paths = [file["path"] for file in files] # Get the paths of all files
return [client.media(path) for path in paths] # Get media for each path
def db_client_update_file(client, filename, file):
try:
metadata = client.metadata(filename)['rev']
except Exception:
metadata = None
client.put_file(filename, file, parent_rev=metadata)
client = client.DropboxClient(sess)
# Show account information...method returns a dictionary, store that for further tests -- Not needed for now
#Client_info = client.account_info()
#Now create a dictionary containing the file name, and it's size
if os.path.lexists(SYNC_DIR):
for file in os.listdir(SYNC_DIR):
SYNC_DIR_LIST[file] = os.path.getsize(SYNC_DIR + '/' + file)
#Get the same from your dropbox
if DEST_DIR in client.metadata('/')['contents'][0]['path']:
SYNC_DIR_META = client.metadata(DEST_DIR)
print 'Destination directory already exists'
else:
client.file_create_folder(DEST_DIR)
SYNC_DIR_META = client.metadata(DEST_DIR)
print 'Just created the destination directory'
SYNC_DIR_META_LIST = {}
#Create a dictionary with the same info as SYNC_DIR_LIST
for file in SYNC_DIR_META['contents']:
SYNC_DIR_META_LIST[os.path.split(file['path'])[1]] = file['bytes']
#Copy only if file does not exist on Dropbox, or size different from source(modified file) or does not start with . (hidden files)
for file in SYNC_DIR_LIST:
if (file[0] != '.'):
print "url:", url
print "Please authorize in the browser. After you're done, press Enter."
raw_input()
access_token = sess.obtain_access_token(request_token)
try:
with open("/tmp/dropbox_token.pkl", "w") as f:
f.write("%s|%s" % (access_token.key, access_token.secret))
except IOError:
pass
except AttributeError as e:
print "Internal Error: " % e
client = client.DropboxClient(sess)
m = client.metadata("/")
if m['is_dir']:
files = m['contents']
else:
files = [m]
for (i,f) in enumerate(files):
print i, f['path']
print "Which file?"
ixFile = int(raw_input())
selectedFile = files[ixFile]
if selectedFile['is_dir']:
print "Sorry, but only files have revisions."
sys.exit(2)
print "Getting revisions of %s" % selectedFile['path']
revs = client.revisions(selectedFile['path'])
def db_client_update_file(client,filename,file):
try:
metadata = client.metadata(filename)['rev'];
except Exception:
metadata = None
client.put_file(filename,file,parent_rev=metadata)
print "Creating directory:", path
os.makedirs(path)
def lreplace(pattern, sub, string):
return re.sub('^%s' % pattern, sub, string)
# make connection to dropbox
print "Connecting to dropbox..."
sess = session.DropboxSession(args.app_key, args.app_secret, args.access_type)
sess.set_token(args.access_token_key, args.access_token_secret)
client = client.DropboxClient(sess)
# get list of files for args.dropbox_dir
print "Fetching list of files in:", args.dropbox_dir
metadata = client.metadata(args.dropbox_dir)
def files_only(metadata): return metadata['is_dir'] == False
files = map(lambda metadata: metadata['path'], filter(files_only, metadata['contents']))
# download files to args.dest_dir
assure_path_exists(args.dest_dir)
for file in files:
dest_file = args.dest_dir + lreplace(args.dropbox_dir, '', file)
print "Downloading file: %s to: %s" % (file, dest_file)
response = client.get_file(file)
with open(dest_file, 'wb') as out:
while not response.isclosed():
out.write(response.read(1024 * 1024))
# remove files in args.dropbox_dir
if args.remove_downloaded_files == True:
def blog_index_handle(template='index.html', content_type='text/html'):
log.debug('blog_index_handle()')
target_file = "posts"
client = dropbox.client.DropboxClient(CONFIG.DROPBOX_PRIVATE_TOKEN)
dropbox_response = client.metadata(
target_file, list=True)
files = dropbox_response['contents']
files = sorted(
files,
key=lambda f: f['path'],
reverse=True)
files = files[:10]
log.debug(files)
for f in files:
log.debug(f['path'])
file_response, dropbox_meta = client.get_file_and_metadata(
f['path'])
f.update(dropbox_meta)
log.debug(f['path'])
file_content = file_response.read()
fdata = process_markdown(
target_file, file_content)
log.debug(fdata)
f.update(fdata)
log.debug(f['path'])
# fix title
f.update(f['meta'])
if 'Title' in f:
f['title'] = f['Title']
# permalink
f['permalink'] = url_for_path(f['path'])
log.debug(f)
# log.debug(files)
template_response, meta = client.get_file_and_metadata(
'templates/%s' % template)
template_content = template_response.read()
page_content = render_template(template_content, {
'posts': files,
})
resp = make_response(page_content)
resp.headers["Content-Type"] = content_type
return resp
def list_files(src): response = client.metadata(src) #print "Response:\n" + response return response
# coding: utf-8
# https://forum.omz-software.com/topic/3224/tls-ssl-exceptions-from-pythonista-2-1/2
from dropbox import client, session
APP_KEY = 'aaaaaaaaaaaaaaa'
APP_SECRET = 'bbbbbbbbbbbbbbb'
ACCESS_TYPE = 'dropbox'
ACCESS_KEY = 'cccccccccccccccc'
ACCESS_SECRET = 'ddddddddddddddd'
sess = session.DropboxSession(APP_KEY, APP_SECRET, ACCESS_TYPE)
sess.set_token(ACCESS_KEY, ACCESS_SECRET)
client = client.DropboxClient(sess)
folder_metadata = client.metadata('/')
# --------------------
dropbox.dropbox.requests.packages.urllib3.disable_warnings()
# --------------------
def recursive_get_folder(client, folder):
folder_metadata = client.metadata(folder)
for c in folder_metadata["contents"]:
if c["is_dir"]:
dirname = BASE_PATH + c["path"]
sys.stdout.write("Found directory %s ... " % dirname)
sys.stdout.flush()
if os.path.exists(dirname):
sys.stdout.write("Exists local.\n")
else:
sys.stdout.write("Creating local...")
sys.stdout.flush()
os.makedirs(dirname)
sys.stdout.write("Done.\n")
sys.stdout.flush()
previous_cwd = os.getcwd()
os.chdir(dirname)
recursive_get_folder(client, c["path"])
os.chdir(previous_cwd)
else:
# Check if the file exists
download = True
local_filename = BASE_PATH + c["path"]
sys.stdout.write("Checking %s ... " % c["path"])
sys.stdout.flush()
if os.path.exists(local_filename):
sys.stdout.write("Exists ")
sys.stdout.flush()
# Compare if they are the same
if os.path.getsize(local_filename) == c["bytes"]:
# FIXME: Improve reliability
#if os.path.getmtime(filename) == c.client_mtime:
sys.stdout.write("and are the same.\n")
sys.stdout.flush()
download = False
else:
sys.stdout.write("but aren't the same. ")
else:
sys.stdout.write("Does not exist. ")
sys.stdout.flush()
if download:
# Download the file
sys.stdout.write("\nDownloading.. ")
sys.stdout.flush()
out = open(local_filename, "wb")
f, metadata = client.get_file_and_metadata(c["path"])
total_size = metadata["bytes"]
written = 0
while True:
data = f.read(CHUNK_SIZE)
if data == '':
break
else:
out.write(data)
written = written + len(data)
percent = written * 30 / total_size
#percent_line = "[" + ("*" * percent) +
# (" " * (30 - percent)) +
# "] " + str(written) + "/" +
# str(total_size)
percent_line = "[%s%s] %d/%d" % (("*" * percent),
(" " * (30 - percent)),
written, total_size)
sys.stderr.write(percent_line)
sys.stderr.write("\b" * (len(percent_line)))
sys.stderr.flush()
out.close()
sys.stdout.write("Done. \n")
