def get_images_of_this_month(): client = DropboxClient(DROPBOX_TOKEN) manager = DatastoreManager(client) datastore = manager.open_default_datastore() offer_table = datastore.get_table('offers') offers = offer_table.query() images_to_show = [] for offer in offers: # dropbox.datastore.Record name = offer.get('offerName') begin = datetime.datetime.strptime(offer.get('begin'), "%Y-%m-%d").date() end = datetime.datetime.strptime(offer.get('end'), "%Y-%m-%d").date() begin_month = '{:02d}'.format(begin.month) end_month = '{:02d}'.format(end.month) current_month = '{:02d}'.format(datetime.datetime.now().month) year = '{:4d}'.format(datetime.datetime.now().year) if current_month == begin_month or current_month == end_month: # belong to the current month, so we show it images_to_show.append(name) images_paths = download_and_save_images(images_to_show, year, current_month) TEMPLATE_PATH.insert(0, 'pages/') return template('galeria', images=images_paths)
def main(): global client global datastore global geoData access_token = connect() client = DropboxClient(access_token) print 'linked account: ', client.account_info()["display_name"] manager = DatastoreManager(client) datastore = manager.open_default_datastore() # manager.delete_datastore("default") geoData = datastore.get_table('GeoData') app = MyApp(0) app.MainLoop() # folder_metadata = client.metadata('/GeoDrive') # # print 'metadata: ', folder_metadata["contents"] # for geoFile in folder_metadata["contents"]: # # print file # print geoFile["path"] + "\n\tclient_mtime:" + geoFile["client_mtime"] + "\n\tmodified:" + geoFile["modified"] # entry = geoData.query(path=geoFile["path"]) # print entry # print "Distance: " + str(distance_on_earth(33.644277, -117.842026, 33.645147, -117.831879)) # geoData.insert(path='/GeoDrive/Work.txt', lat=33.644277, long=-117.842026, lastLoc=Date()) # geoData.insert(path='/GeoDrive/Home.txt', lat=33.645147, long=-117.831879, lastLoc=Date()) datastore.commit()
def __init__(self, master, client): Frame.__init__(self, master) # Connect to Dropbox and open datastore. self.manager = DatastoreManager(client) # Try to load serialized datastore first. datastore = self.load_serialized_datastore(SERIALIZED_DATASTORE) if datastore is not None: try: datastore.load_deltas() except DatastoreNotFoundError: print 'This datastore has been deleted. Exiting now.' sys.exit(1) except HTTPError: print 'We are offline. Proceed with caution.' else: datastore = self.manager.open_default_datastore() self.datastore = datastore self.table = self.datastore.get_table('tasks') # Set up communication with background thread. self.queue = Queue() # Holds deltas sent from background thread. self.display_rev = 0 # Last revision displayed. self.refresh() # Initial display update. self.bind(REFRESH_EVENT, self.refresh) # Respond to background thread. # Create, configure and start background thread. self.bg_thread = Thread(name='bgthread', target=self.bg_run) self.bg_thread.setDaemon(True) self.bg_thread.start()
def __init__(self, app_key, app_secret): cmd.Cmd.__init__(self) self.app_key = app_key self.app_secret = app_secret self.current_path = '' self.prompt = "Dropbox> " self.api_client = None try: serialized_token = open(self.TOKEN_FILE).read() if serialized_token.startswith('oauth1:'): access_key, access_secret = serialized_token[len('oauth1:'):].split(':', 1) sess = session.DropboxSession(self.app_key, self.app_secret) sess.set_token(access_key, access_secret) self.api_client = client.DropboxClient(sess) self.manager = DatastoreManager(self.api_client) self.datastore = self.manager.open_default_datastore() print "[loaded OAuth 1 access token]" elif serialized_token.startswith('oauth2:'): access_token = serialized_token[len('oauth2:'):] self.api_client = DropboxClient(access_token) self.manager = DatastoreManager(self.api_client) self.datastore = self.manager.open_default_datastore() print "[loaded OAuth 2 access token]" else: print "Malformed access token in %r." % (self.TOKEN_FILE,) except IOError: pass # don't worry if it's not there
def deleteR(): client = DropboxClient(DROPBOX_TOKEN) manager = DatastoreManager(client) datastore = manager.open_default_datastore() tasks_table = datastore.get_table('uk_devices') tasks = tasks_table.query(instStatus='on') for task in tasks: print task.get('serialNumber') task.delete() datastore.transaction(deleteR, max_tries=4) datastore.commit()
def bg_run(self): # This code runs in a background thread. No other code does. deltamap = None backoff = 0 while True: cursor_map = DatastoreManager.make_cursor_map([self.datastore], deltamap) try: _, _, deltamap = self.manager.await(datastores=cursor_map) except Exception as exc: if isinstance(exc, HTTPError): if not backoff: print 'We have gone offline.' else: print 'We are still offline.' else: print 'bg_run():', repr(exc), str(exc) # Randomized exponential backoff, clipped to 5 minutes. backoff = min(backoff*2, 300) + random.random() time.sleep(backoff) continue else: if backoff: print 'We have come back online.' backoff = 0 if deltamap and self.datastore in deltamap: deltas = deltamap[self.datastore] if deltas is None: # Stop the bg thread. print 'This datastore has been deleted.' print 'Please exit.' break if deltas: self.queue.put(deltas) self.event_generate(REFRESH_EVENT, when='tail')
def bg_run(self): # This code runs in a background thread. No other code does. deltamap = None backoff = 0 while True: cursor_map = DatastoreManager.make_cursor_map([self.datastore], deltamap) try: _, _, deltamap = self.manager. await (datastores=cursor_map) except Exception as exc: if isinstance(exc, HTTPError): if not backoff: print 'We have gone offline.' else: print 'We are still offline.' else: print 'bg_run():', repr(exc), str(exc) # Randomized exponential backoff, clipped to 5 minutes. backoff = min(backoff * 2, 300) + random.random() time.sleep(backoff) continue else: if backoff: print 'We have come back online.' backoff = 0 if deltamap and self.datastore in deltamap: deltas = deltamap[self.datastore] if deltas is None: # Stop the bg thread. print 'This datastore has been deleted.' print 'Please exit.' break if deltas: self.queue.put(deltas) self.event_generate(REFRESH_EVENT, when='tail')
class CheckEEW(): def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.process() def process(self): for bridge in self.bridges: print bridge fileName = bridge + ".csv" self.f = open(fileName, "w", 0) rows = [] ds = self.manager.open_or_create_datastore(bridge) t = ds.get_table('config') devices = t.query(type='idtoname') values = [] commas = "" heads = "Time," for d in devices: devHandle = d.get('device') devName = d.get('name') self.f.write(devHandle + ',' + devName + '\n') t = ds.get_table(devHandle) for sensor in SENSORS: heads = heads + devName + ' ' + sensor + ',' readings = t.query(Type=sensor) max = 0 for r in readings: timeStamp = float(r.get('Date')) if timeStamp > max: max = timeStamp dat = r.get('Data') line = commas + str("%2.1f" %dat) values.append([timeStamp, line]) commas += "," rows.append([devHandle, devName, sensor, niceTime(max)]) values.sort(key=lambda tup: tup[0]) self.f.write(heads + '\n') for v in values: line = niceTime(v[0]) + "," + v[1] + "\n" self.f.write(line)
def main(): args = sys.argv[1:] if len(args) == 1: client = DropboxClient(args[0]) elif len(args) == 2: client = login(*args) else: print >> sys.stderr, 'Usage: shtasks.py ACCESS_TOKEN' print >> sys.stderr, 'or: shtasks.py APP_KEY APP_SECRET' print >> sys.stderr, 'To get an app key and secret: https://www.dropbox.com/developers/apps' sys.exit(2) mgr = DatastoreManager(client) ds = mgr.open_default_datastore() tab = ds.get_table('tasks') for rec in sorted(tab.query(), key=lambda rec: rec.get('created')): completed = rec.get('completed') taskname = rec.get('taskname') print '[%s] %s' % ('X' if completed else ' ', taskname)
def main(): args = sys.argv[1:] if len(args) == 1: client = DropboxClient(args[0]) elif len(args) == 2: client = login(*args) else: print >>sys.stderr, 'Usage: shtasks.py ACCESS_TOKEN' print >>sys.stderr, 'or: shtasks.py APP_KEY APP_SECRET' print >>sys.stderr, 'To get an app key and secret: https://www.dropbox.com/developers/apps' sys.exit(2) mgr = DatastoreManager(client) ds = mgr.open_default_datastore() tab = ds.get_table('tasks') for rec in sorted(tab.query(), key=lambda rec: rec.get('created')): completed = rec.get('completed') taskname = rec.get('taskname') print '[%s] %s' % ('X' if completed else ' ', taskname)
def saveDataOnDropbox(phone, serial, date, instalation): client = DropboxClient(DROPBOX_TOKEN) manager = DatastoreManager(client) datastore = manager.open_default_datastore() devices_table = datastore.get_table('uk_devices') for _ in range(MAX_RETRIES): try: first_offer = devices_table.insert(phoneNumber=phone, serialNumber=serial, dateActivate=date, instStatus=instalation) datastore.commit() _logger.debug("data saved on offers table = (%s, %s, %s, %s)" % (phone, serial, date, instalation)) break except DatastoreConflictError: datastore.rollback() # roll back local changes datastore.load_deltas() # load new changes from Dropbox
class CheckEEW(): def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() #print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.process() def process(self): for bridge in self.bridges: print bridge rows = [] ds = self.manager.open_or_create_datastore(bridge) t = ds.get_table('config') devices = t.query(type='idtoname') print "" for d in devices: devHandle = d.get('device') devName = d.get('name') t = ds.get_table(devHandle) for sensor in SENSORS: readings = t.query(Type=sensor) values = [] max = 0 for r in readings: timeStamp = float(r.get('Date')) if timeStamp > max: max = timeStamp dat = r.get('Data') values.append([timeStamp, dat]) #values.sort(key=lambda tup: tup[0]) #for v in values: #line = self.niceTime(v[0]) + "," + str("%2.1f" %v[1]) + "\n" #self.f.write(line) rows.append([devHandle, devName, sensor, niceTime(max)]) header = ('Handle', 'Friendly Name', 'Sensor', 'Most Recent Sample') txt = matrix_to_string(rows, header) print txt
def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client)
def __init__(self, argv): if len(argv) < 2: print "Usage: makecvs <bridge name> " exit(1) self.bridge = argv[1] self.bridge = self.bridge.lower() print "Writing cvs files for ", self.bridge access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.ds = self.manager.open_or_create_datastore(self.bridge) self.process()
def get_game_ds(): game_ds = getattr(fglobal, '_game_ds', None) if game_ds: game_ds.commit() game_ds.load_deltas() return game_ds GOD_DS.load_deltas() main_table = GOD_DS.get_table('main') records = main_table.query() if len(records) < 1: # Create ds game_ds = GOD_DS_MAN.create_datastore() # Make it shared and viewable to the public game_ds.set_role(Datastore.PUBLIC, Datastore.VIEWER) game_ds.commit() # Store the id main_table.insert(game_ds_id=game_ds.get_id()) GOD_DS.commit() else: record = records.pop() game_ds_id = record.get('game_ds_id') game_ds = DatastoreManager(GOD_CLIENT).open_datastore(game_ds_id) fglobal._game_ds = game_ds game_ds.commit() game_ds.load_deltas() return game_ds
class MakeCVS(): def __init__(self, argv): if len(argv) < 2: print "Usage: makecvs <bridge name> " exit(1) self.bridge = argv[1] self.bridge = self.bridge.lower() print "Writing cvs files for ", self.bridge access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.ds = self.manager.open_or_create_datastore(self.bridge) self.process() def niceTime(self, timeStamp): localtime = time.localtime(timeStamp) milliseconds = '%03d' % int((timeStamp - int(timeStamp)) * 1000) now = time.strftime('%Y:%m:%d, %H:%M:%S:', localtime) + milliseconds return now def process(self): idToName = {} devTable = {} ir_temps = [] t = self.ds.get_table('config') devices = t.query(type='idtoname') for d in devices: idToName[d.get('device')] = d.get('name') print "idToName: ", idToName for d in idToName: fileName = d + ".csv" self.f = open(fileName, "w", 0) t = self.ds.get_table(d) temps = t.query(Type='ir_temperature') values = [] for t in temps: timeStamp = float(t.get('Date')) temp = t.get('Data') values.append([timeStamp, temp]) values.sort(key=lambda tup: tup[0]) for v in values: line = self.niceTime(v[0]) + "," + str("%2.1f" %v[1]) + "\n" self.f.write(line)
def post(self): args = parser.parse_args() new_note = { 'lat': args.lat, 'lng': args.lng, 'dt': args.date, 'txt': args.text_content, } if args.media_content: _, ext = os.path.splitext(args.media_content.filename) new_note['ext'] = ext _id = new_note['_id'] = mongo.db.geonauts.insert(new_note) if args.media_content: filename = "%s%s" % (_id, ext) mongo.save_file(filename, args.media_content) new_note['url'] = url_for_media(new_note) #add to dropbox if current_app.config["UPLOAD_TO_DROPBOX"]: if new_note.get('ext'): dropbox.client.put_file(filename, args.media_content) datastore = DatastoreManager(dropbox.client).open_default_datastore() notes_table = datastore.get_table('geonotes') def do_insert(): drop_note = { '_id': str(new_note['_id']), 'lat': new_note['lat'], 'lng': new_note['lng'], 'date': Date(datetime2timestamp(new_note['dt'])), 'text_content': new_note['txt'], } if 'ext' in new_note: drop_note['media_content'] = new_note['ext'] notes_table.insert(**drop_note) datastore.transaction(do_insert, max_tries=4) return marshal(new_note, note_fields), 201
def open_datastore(refresh=False): access_token = session.get("access_token") if not access_token: return None datastore = cache.get(access_token) try: if datastore is not None: # Delete the cache entry now, so that if the refresh fails we # don't cache the probably invalid datastore. del cache[access_token] if refresh: datastore.load_deltas() else: client = DropboxClient(access_token) manager = DatastoreManager(client) datastore = manager.open_default_datastore() if len(cache) >= 32: to_delete = next(iter(cache)) del cache[to_delete] except (ErrorResponse, DatastoreError): app.logger.exception("An exception occurred opening a datastore") return None cache[access_token] = datastore return datastore
def open_datastore(refresh=False): access_token = session.get('access_token') if not access_token: return None datastore = cache.get(access_token) try: if datastore is not None: # Delete the cache entry now, so that if the refresh fails we # don't cache the probably invalid datastore. del cache[access_token] if refresh: datastore.load_deltas() else: client = DropboxClient(access_token) manager = DatastoreManager(client) datastore = manager.open_default_datastore() if len(cache) >= 32: to_delete = next(iter(cache)) del cache[to_delete] except (ErrorResponse, DatastoreError): app.logger.exception('An exception occurred opening a datastore') return None cache[access_token] = datastore return datastore
def saveOnDropbox(full_path, filename, begin, end): client = DropboxClient(DROPBOX_TOKEN) manager = DatastoreManager(client) datastore = manager.open_default_datastore() offer_table = datastore.get_table('offers') for _ in range(MAX_RETRIES): try: first_offer = offer_table.insert(offerName=filename, begin=begin, end=end) datastore.commit() _logger.debug("data saved on offers table = (%s, %s, %s)" % (filename, begin, end)) break except DatastoreConflictError: datastore.rollback() # roll back local changes datastore.load_deltas() # load new changes from Dropbox image = open(full_path, 'rb') response = client.put_file(filename, image) image.close() _logger.debug("%s saved on dropbox" % filename)
def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.process()
def dsCreate(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.open_or_create_datastore(params[0]) print(str(result))
def dsDelete(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.delete_datastore(params[0], True) print(str(result))
class CheckEEW(): def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) self.process() def niceTime(self, timeStamp): localtime = time.localtime(timeStamp) milliseconds = '%03d' % int((timeStamp - int(timeStamp)) * 1000) now = time.strftime('%Y:%m:%d, %H:%M:%S:', localtime) + milliseconds return now def matrix_to_string(self,matrix, header=None): """ Return a pretty, aligned string representation of a nxm matrix. This representation can be used to print any tabular data, such as database results. It works by scanning the lengths of each element in each column, and determining the format string dynamically. @param matrix: Matrix representation (list with n rows of m elements). @param header: Optional tuple or list with header elements to be displayed. """ if type(header) is list: header = tuple(header) lengths = [] if header: for column in header: lengths.append(len(column)) for row in matrix: for column in row: i = row.index(column) column = str(column) cl = len(column) try: ml = lengths[i] if cl > ml: lengths[i] = cl except IndexError: lengths.append(cl) lengths = tuple(lengths) format_string = "" for length in lengths: format_string += "%-" + str(length) + "s " format_string += "\n" matrix_str = "" if header: matrix_str += format_string % header for row in matrix: matrix_str += format_string % tuple(row) return matrix_str def process(self): for bridge in self.bridges: print "Reaading and processing data for ", bridge fileName = bridge + ".csv" self.f = open(fileName, "w", 0) rows = [] ds = self.manager.open_or_create_datastore(bridge) t = ds.get_table('config') devices = t.query(type='idtoname') values = [] commas = "" heads = "" devSensors = [] for d in devices: devHandle = d.get('device') devName = d.get('name') self.f.write(devHandle + ',' + devName + '\n') t = ds.get_table(devHandle) for sensor in SENSORS: heads = heads + devName + ' ' + sensor + ',' devSensors.append([devName, sensor]) readings = t.query(Type=sensor) max = 0 for r in readings: timeStamp = float(r.get('Date')) if timeStamp > max: max = timeStamp dat = r.get('Data') line = commas + str("%2.1f" %dat) values.append([timeStamp, line]) commas += "," rows.append([devHandle, devName, sensor, self.niceTime(max)]) values.sort(key=lambda tup: tup[0]) print "Type the numbers of the values you want to plot, separated by spaces:" for d in devSensors: print devSensors.index(d) + 1, ":", d[0], d[1] request = raw_input("Values > ") toProcess = request.split() print "toProcess: ", toProcess
class DropShell: def __init__(self): self.config = configparser.ConfigParser() self.config.read('dropshell.ini') self.settings = self.config["DropBox"] self.wdPath = [] self.datastoreManager = None def getFilePath(self, fileName): if len(self.wdPath) == 0: return '/' + fileName return '/' + '/'.join(self.wdPath) + '/' + fileName def appAuthorization(self): print('Application authorization required') print('---------------------------------------------------------\n') app_key = self.settings['AppKey'] app_secret= self.settings['AppKeySecret'] flow = dropbox.client.DropboxOAuth2FlowNoRedirect(app_key, app_secret) authorize_url = flow.start() print(' 1. Go to: ' + authorize_url) # "AppName" moechte auf ihren eigenen Ordner Apps > NotesWiki in Ihrer Dropbox zugreifen. # Allow, Deny print(' 2. Click "Allow" (you might have to log in first)') print(' 3. Copy the authorization code.\n') code = input("Enter the authorization code here: ").strip() access_token, user_id = flow.finish(code) # "The access token is all you'll need to make API requests on behalf # of this user, so you should store it away for safe-keeping. # By storing the access token, you won't need to go through these steps # again unless the user reinstalls your app or revokes access via the # Dropbox website." self.settings['UserAccessToken'] = access_token self.settings['UserAccessId'] = user_id with open('dropshell.ini', 'w') as dropshellIni: self.config.write(dropshellIni, False) def processCommand(self, tokens): cmd = tokens[0].lower() if cmd == "quit": self.isRunning = False elif cmd == "connect": self.connect(tokens[1:]) elif cmd == "ls": self.listFiles(tokens[1:]) elif cmd == "cd": self.changeDirectory(tokens[1:]) elif cmd == "info": self.showAccountInfo() elif cmd == "put": self.putFile(tokens[1:]) elif cmd == "get": self.getFile(tokens[1:]) elif cmd == "rm": self.deleteFile(tokens[1:]) elif cmd == "mkdir": self.mkdir(tokens[1:]) elif cmd == "rmdir": self.rmdir(tokens[1:]) elif cmd == "help": self.showHelp() elif cmd == "dscreate": self.dsCreate(tokens[1:]) elif cmd == "dslist": self.dsList() else: print("Syntax error: {}".format(tokens)) def showHelp(self): print(''' Available commands: ------------------- help - Show this help summary connect - Connect to dropbox info - Show information about the connection ls [-l] - Show files and folders in the current folder cd path - Change the current path mkdir folderName - Creates a new folder in the current folder put fileName - Upload a file to the current folder get fileName - Download a file from the current folder rm name - Deletes the specified file or folder from the current folder ds - execute a Datastore API sample quit - Leave the command line client''') def connect(self, parameters): if self.settings.get('useraccesstoken') is None: self.appAuthorization() self.client = dropbox.client.DropboxClient(self.settings['useraccesstoken']) print("Connected.") self.showAccountInfo() def showAccountInfo(self): info = self.client.account_info() print("Connection information") print("-------------------------------") print(' User : {}'.format(info['display_name'])) print(' eMail: {}'.format(info['email'])) print() def listFiles(self, parameters): isLong = len(parameters) > 0 and parameters[0] == '-l' # Depending on the application type / security settings, the # root directory "/" either points to the applications root directory # (e.g. DropBox > Apps > NotesWiki) or to the User's root directory # ("DropBox") wd = '/' + '/'.join(self.wdPath) contents = self.client.metadata(wd) files = contents['contents'] print() for f in files: filePath = f['path'].split('/') fileName = filePath[-1] isDir = f['is_dir'] if isLong: # Www, DD Mmm YYYY HH:MM:SS +Tz mDate = time.strptime(f['modified'], "%a, %d %b %Y %H:%M:%S %z") printDate = time.strftime("%b %d %Y %H:%M:%S", mDate) size = f['size'] print('{:>10} {} {}{}'.format(size, printDate, fileName, '/' if isDir else '')) else: print('{}{}'.format(fileName, '/' if isDir else '')) def changeDirectory(self, parameters): dirName = parameters[0] if dirName == '..': if len(self.wdPath) > 0: self.wdPath = self.wdPath[:-1] else: self.wdPath.append(dirName) def putFile(self, params): remoteFileName = self.getFilePath(params[0]) print("Uploading: {} => {}".format(params[0], remoteFileName)) f = open(params[0], 'rb') response = self.client.put_file(remoteFileName, f) print("Uploaded {} bytes.".format(response['size'])) #f = open('working-draft.txt', 'rb') #response = client.put_file('/magnum-opus.txt', f) #print "uploaded:", response def getFile(self, params): remoteFileName = self.getFilePath(params[0]) print("Downloading: {} => {}".format(remoteFileName, params[0])) out = open(params[0], 'wb') with self.client.get_file(remoteFileName) as f: out.write(f.read()) print("Done.") def mkdir(self, params): remoteDirName = self.getFilePath(params[0]) result = self.client.file_create_folder(remoteDirName) print("Created directory {}".format(result['path'])) #def rmdir(self, params): # remoteDirName = self.getFilePath(params[0]) # result = self.client.file_delete(remoteDirName) # print("Removed directory {}".format(result['path'])) def deleteFile(self, params): remoteFileName = self.getFilePath(params[0]) response = self.client.file_delete(remoteFileName) print("Removed {} {}".format("directory" if response['is_dir'] else "file", response['path'])) # Datastore API samples def dsCreate(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.open_or_create_datastore(params[0]) print(str(result)) def dsDelete(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.delete_datastore(params[0], True) print(str(result)) def dsList(self): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.list_datastores() for ds in result: print(str(ds)) def processInput(self): self.connect(None) self.isRunning = True while self.isRunning: wd = '/' + '/'.join(self.wdPath) s = input('[DS] {} > '.format(wd)) tokens = s.split(maxsplit=1) if len(tokens) > 0: self.processCommand(tokens) print()
class TaskList(Frame): def __init__(self, master, client): Frame.__init__(self, master) # Connect to Dropbox and open datastore. self.manager = DatastoreManager(client) # Try to load serialized datastore first. datastore = self.load_serialized_datastore(SERIALIZED_DATASTORE) if datastore is not None: try: datastore.load_deltas() except DatastoreNotFoundError: print 'This datastore has been deleted. Exiting now.' sys.exit(1) except HTTPError: print 'We are offline. Proceed with caution.' else: datastore = self.manager.open_default_datastore() self.datastore = datastore self.table = self.datastore.get_table('tasks') # Set up communication with background thread. self.queue = Queue() # Holds deltas sent from background thread. self.display_rev = 0 # Last revision displayed. self.refresh() # Initial display update. self.bind(REFRESH_EVENT, self.refresh) # Respond to background thread. # Create, configure and start background thread. self.bg_thread = Thread(name='bgthread', target=self.bg_run) self.bg_thread.setDaemon(True) self.bg_thread.start() def load_serialized_datastore(self, filename): try: f = open(filename, 'rb') except IOError as exc: # Don't print an error if the file doesn't exist. if os.path.exists(filename): print 'Cannot load saved datastore:', exc return None with f: try: data = json.load(f) id, handle, rev, snapshot = data except ValueError as exc: print 'Bad JSON on %s: %s' % (filename, exc) return None datastore = self.manager.open_raw_datastore(id, handle) # If this fails, the save file is bad -- you must manually delete it. datastore.apply_snapshot(rev, snapshot) print 'Loaded datastore from', filename return datastore def save_serialized_datastore(self, datastore, filename): id = datastore.get_id() handle = datastore.get_handle() rev = datastore.get_rev() snapshot = datastore.get_snapshot() data = [id, handle, rev, snapshot] try: f = open(filename, 'wb') except IOError as exc: print 'Cannot save datastore:', exc return with f: json.dump(data, f) print 'Saved datastore to', filename def bg_run(self): # This code runs in a background thread. No other code does. deltamap = None backoff = 0 while True: cursor_map = DatastoreManager.make_cursor_map([self.datastore], deltamap) try: _, _, deltamap = self.manager. await (datastores=cursor_map) except Exception as exc: if isinstance(exc, HTTPError): if not backoff: print 'We have gone offline.' else: print 'We are still offline.' else: print 'bg_run():', repr(exc), str(exc) # Randomized exponential backoff, clipped to 5 minutes. backoff = min(backoff * 2, 300) + random.random() time.sleep(backoff) continue else: if backoff: print 'We have come back online.' backoff = 0 if deltamap and self.datastore in deltamap: deltas = deltamap[self.datastore] if deltas is None: # Stop the bg thread. print 'This datastore has been deleted.' print 'Please exit.' break if deltas: self.queue.put(deltas) self.event_generate(REFRESH_EVENT, when='tail') def save(self, event=None): self.save_serialized_datastore(self.datastore, SERIALIZED_DATASTORE) def refresh(self, event=None): # This is called directly when we have made a change, # and when the background thread sends a REFRESH_EVENT. self.load_queue() # Update the datastore. if self.datastore.get_rev() == self.display_rev: return # Nothing to do. self.forget() # Hide the frame to reduce flashing. for w in self.winfo_children(): w.destroy() # Delete the old widgets. self.redraw() # Create new widgets. self.pack(fill=BOTH, expand=1) # Show the frame. self.display_rev = self.datastore.get_rev() title = self.datastore.get_title() mtime = self.datastore.get_mtime() if not title: title = 'My Tasks' if mtime: fmtime = mtime.to_datetime_local().strftime('%H:%M, %d %b %Y') title = '%s (%s)' % (title, fmtime) self.master.title(title) self.input.focus_set() def load_queue(self): # Incorporate queued deltas into the datastore. while True: try: deltas = self.queue.get_nowait() except Empty: break else: self.datastore.apply_deltas(deltas) def redraw(self): # Even though there are never more than three widgets per row, # we have four columns, to allow the taskname label and the # input widget to stretch. self.grid_columnconfigure(2, weight=1) row = 0 # Add a new row of widgets for each task. for rec in sorted(self.table.query(), key=lambda rec: rec.get('created')): # Extract the fields we need. completed = rec.get('completed') taskname = rec.get('taskname') # Create a button with an 'X' in it, to delete the task. close_btn = Button(self, text='X', command=lambda rec=rec: self.delete_rec(rec)) close_btn.grid(row=row, column=0) # Create a checkbox, to mark it completed (or not). var = BooleanVar(self, value=completed) completed_btn = Checkbutton( self, variable=var, command=lambda rec=rec, var=var: self.toggle_rec(rec, var)) completed_btn.grid(row=row, column=1) # Create a label showing the task name. taskname_lbl = Label(self, text=taskname, anchor=W) taskname_lbl.grid(row=row, column=2, columnspan=2, sticky=W) row += 1 # Bump row index. # Add a final row with the input and button to add new tasks. self.input = Entry(self) self.input.bind('<Return>', self.add_rec) self.input.grid(row=row, column=0, columnspan=3, sticky=W + E) add_btn = Button(self, text='Add Task', command=self.add_rec) add_btn.grid(row=row, column=3) # Add save button. (Auto-save is left as an exercise.) save_btn = Button(self, text='Save local snapshot', command=self.save) save_btn.grid(row=row + 1, column=0, columnspan=3, sticky=W) def add_rec(self, event=None): # Callback to add a new task. self.do_transaction(self.table.insert, completed=False, taskname=self.input.get(), created=Date()) def delete_rec(self, rec): # Callback to delete a task. self.do_transaction(rec.delete_record) def toggle_rec(self, rec, var): # Callback to toggle a task's completed flag. try: self.do_transaction(rec.set, 'completed', var.get()) finally: # In case the transaction failed, flip the variable back. var.set(rec.get('completed')) def do_transaction(self, func, *args, **kwds): self.update_idletasks() # Refresh screen without handling more input. def call_func(): func(*args, **kwds) try: self.datastore.transaction(call_func, max_tries=4) except Exception as exc: # Maybe the server is down, or we experience extreme conflicts. # NOTE: A more user-friendly way would be to show an error dialog. print 'do_transaction():', repr(exc) else: self.refresh()
from dropbox.rest import ErrorResponse app = Flask(__name__) DEBUG = os.environ.get('DEBUG', True) app.debug = DEBUG app.secret_key = 'a9f3ab10-a345-11e4-89d3-123b93f75cba' DROPBOX_APP_KEY = 'alb0kf2mp7ca1np' DROPBOX_APP_SECRET = '1d06iyf5ixv9y54' DROPBOX_PATH_REGEX = re.compile('.*?view/.*?/(.*)') GOD_CLIENT = DropboxClient( 'qRrmAkXDDlQAAAAAAAAJTo3vU5u627YKYUwHUzTQ2t48OiJvdPHsg5dHF5HS1KyZ') GOD_PATH = 'DBHACK/' GOD_DS_MAN = DatastoreManager(GOD_CLIENT) GOD_DS = GOD_DS_MAN.open_default_datastore() GAME_RUNNING = 'running' GAME_WAITING = 'waiting' WINNER_PATH = 'Apps/sacradash/winnings' def get_dropbox_client(): client = DropboxClient(session['access_token'], locale='en_UK') user_info = client.account_info() session['user_id'] = user_info['uid'] session['display_name'] = user_info['display_name'] return client
class TaskList(Frame): def __init__(self, master, client): Frame.__init__(self, master) # Connect to Dropbox and open datastore. self.manager = DatastoreManager(client) # Try to load serialized datastore first. datastore = self.load_serialized_datastore(SERIALIZED_DATASTORE) if datastore is not None: try: datastore.load_deltas() except DatastoreNotFoundError: print 'This datastore has been deleted. Exiting now.' sys.exit(1) except HTTPError: print 'We are offline. Proceed with caution.' else: datastore = self.manager.open_default_datastore() self.datastore = datastore self.table = self.datastore.get_table('tasks') # Set up communication with background thread. self.queue = Queue() # Holds deltas sent from background thread. self.display_rev = 0 # Last revision displayed. self.refresh() # Initial display update. self.bind(REFRESH_EVENT, self.refresh) # Respond to background thread. # Create, configure and start background thread. self.bg_thread = Thread(name='bgthread', target=self.bg_run) self.bg_thread.setDaemon(True) self.bg_thread.start() def load_serialized_datastore(self, filename): try: f = open(filename, 'rb') except IOError as exc: # Don't print an error if the file doesn't exist. if os.path.exists(filename): print 'Cannot load saved datastore:', exc return None with f: try: data = json.load(f) id, handle, rev, snapshot = data except ValueError as exc: print 'Bad JSON on %s: %s' % (filename, exc) return None datastore = self.manager.open_raw_datastore(id, handle) # If this fails, the save file is bad -- you must manually delete it. datastore.apply_snapshot(rev, snapshot) print 'Loaded datastore from', filename return datastore def save_serialized_datastore(self, datastore, filename): id = datastore.get_id() handle = datastore.get_handle() rev = datastore.get_rev() snapshot = datastore.get_snapshot() data = [id, handle, rev, snapshot] try: f = open(filename, 'wb') except IOError as exc: print 'Cannot save datastore:', exc return with f: json.dump(data, f) print 'Saved datastore to', filename def bg_run(self): # This code runs in a background thread. No other code does. deltamap = None backoff = 0 while True: cursor_map = DatastoreManager.make_cursor_map([self.datastore], deltamap) try: _, _, deltamap = self.manager.await(datastores=cursor_map) except Exception as exc: if isinstance(exc, HTTPError): if not backoff: print 'We have gone offline.' else: print 'We are still offline.' else: print 'bg_run():', repr(exc), str(exc) # Randomized exponential backoff, clipped to 5 minutes. backoff = min(backoff*2, 300) + random.random() time.sleep(backoff) continue else: if backoff: print 'We have come back online.' backoff = 0 if deltamap and self.datastore in deltamap: deltas = deltamap[self.datastore] if deltas is None: # Stop the bg thread. print 'This datastore has been deleted.' print 'Please exit.' break if deltas: self.queue.put(deltas) self.event_generate(REFRESH_EVENT, when='tail') def save(self, event=None): self.save_serialized_datastore(self.datastore, SERIALIZED_DATASTORE) def refresh(self, event=None): # This is called directly when we have made a change, # and when the background thread sends a REFRESH_EVENT. self.load_queue() # Update the datastore. if self.datastore.get_rev() == self.display_rev: return # Nothing to do. self.forget() # Hide the frame to reduce flashing. for w in self.winfo_children(): w.destroy() # Delete the old widgets. self.redraw() # Create new widgets. self.pack(fill=BOTH, expand=1) # Show the frame. self.display_rev = self.datastore.get_rev() title = self.datastore.get_title() mtime = self.datastore.get_mtime() if not title: title = 'My Tasks' if mtime: fmtime = mtime.to_datetime_local().strftime('%H:%M, %d %b %Y') title = '%s (%s)' % (title, fmtime) self.master.title(title) self.input.focus_set() def load_queue(self): # Incorporate queued deltas into the datastore. while True: try: deltas = self.queue.get_nowait() except Empty: break else: self.datastore.apply_deltas(deltas) def redraw(self): # Even though there are never more than three widgets per row, # we have four columns, to allow the taskname label and the # input widget to stretch. self.grid_columnconfigure(2, weight=1) row = 0 # Add a new row of widgets for each task. for rec in sorted(self.table.query(), key=lambda rec: rec.get('created')): # Extract the fields we need. completed = rec.get('completed') taskname = rec.get('taskname') # Create a button with an 'X' in it, to delete the task. close_btn = Button(self, text='X', command=lambda rec=rec: self.delete_rec(rec)) close_btn.grid(row=row, column=0) # Create a checkbox, to mark it completed (or not). var = BooleanVar(self, value=completed) completed_btn = Checkbutton(self, variable=var, command=lambda rec=rec, var=var: self.toggle_rec(rec, var)) completed_btn.grid(row=row, column=1) # Create a label showing the task name. taskname_lbl = Label(self, text=taskname, anchor=W) taskname_lbl.grid(row=row, column=2, columnspan=2, sticky=W) row += 1 # Bump row index. # Add a final row with the input and button to add new tasks. self.input = Entry(self) self.input.bind('<Return>', self.add_rec) self.input.grid(row=row, column=0, columnspan=3, sticky=W+E) add_btn = Button(self, text='Add Task', command=self.add_rec) add_btn.grid(row=row, column=3) # Add save button. (Auto-save is left as an exercise.) save_btn = Button(self, text='Save local snapshot', command=self.save) save_btn.grid(row=row+1, column=0, columnspan=3, sticky=W) def add_rec(self, event=None): # Callback to add a new task. self.do_transaction(self.table.insert, completed=False, taskname=self.input.get(), created=Date()) def delete_rec(self, rec): # Callback to delete a task. self.do_transaction(rec.delete_record) def toggle_rec(self, rec, var): # Callback to toggle a task's completed flag. try: self.do_transaction(rec.set, 'completed', var.get()) finally: # In case the transaction failed, flip the variable back. var.set(rec.get('completed')) def do_transaction(self, func, *args, **kwds): self.update_idletasks() # Refresh screen without handling more input. def call_func(): func(*args, **kwds) try: self.datastore.transaction(call_func, max_tries=4) except Exception as exc: # Maybe the server is down, or we experience extreme conflicts. # NOTE: A more user-friendly way would be to show an error dialog. print 'do_transaction():', repr(exc) else: self.refresh()
def connect(self): manager = DatastoreManager(self.api_client) self.datastore = manager.open_default_datastore()
class DropboxTerm(cmd.Cmd): TOKEN_FILE = "token_store.txt" def __init__(self, app_key, app_secret): cmd.Cmd.__init__(self) self.app_key = app_key self.app_secret = app_secret self.current_path = '' self.prompt = "Dropbox> " self.api_client = None try: serialized_token = open(self.TOKEN_FILE).read() if serialized_token.startswith('oauth1:'): access_key, access_secret = serialized_token[len('oauth1:'):].split(':', 1) sess = session.DropboxSession(self.app_key, self.app_secret) sess.set_token(access_key, access_secret) self.api_client = client.DropboxClient(sess) self.manager = DatastoreManager(self.api_client) self.datastore = self.manager.open_default_datastore() print "[loaded OAuth 1 access token]" elif serialized_token.startswith('oauth2:'): access_token = serialized_token[len('oauth2:'):] self.api_client = DropboxClient(access_token) self.manager = DatastoreManager(self.api_client) self.datastore = self.manager.open_default_datastore() print "[loaded OAuth 2 access token]" else: print "Malformed access token in %r." % (self.TOKEN_FILE,) except IOError: pass # don't worry if it's not there def push_to_dropbox(self, content): table = self.datastore.get_table('tasks') def txn(): table.insert(completed=False, taskname=content, created=Date()) try: self.datastore.transaction(txn, max_tries=4) except DatastoreError: return 'Sorry, something went wrong. Please hit back or reload.' @command(login_required=True) def do_track_clipboard(self): last_paste = paste() while True: content = paste() if content != last_paste: self.push_to_dropbox(content) last_paste = content sleep(1) @command(login_required=False) def do_login(self): """log in to a Dropbox account""" flow = client.DropboxOAuth2FlowNoRedirect(self.app_key, self.app_secret) authorize_url = flow.start() sys.stdout.write("1. Go to: " + authorize_url + "\n") sys.stdout.write("2. Click \"Allow\" (you might have to log in first).\n") sys.stdout.write("3. Copy the authorization code.\n") code = raw_input("Enter the authorization code here: ").strip() try: access_token, user_id = flow.finish(code) except rest.ErrorResponse, e: self.stdout.write('Error: %s\n' % str(e)) return with open(self.TOKEN_FILE, 'w') as f: f.write('oauth2:' + access_token) self.api_client = client.DropboxClient(access_token)
import os from dropbox.client import DropboxClient, DropboxOAuth2Flow, DropboxOAuth2FlowNoRedirect from dropbox.rest import ErrorResponse, RESTSocketError from dropbox.datastore import DatastoreError, DatastoreManager, Datastore, Date, Bytes access_token = os.environ['DROPBOX_ACCESS_TOKEN'] client = DropboxClient(access_token) manager = DatastoreManager(client) shared_dsid = os.environ['DROPBOX_SHARED_QUEUE_DSID'] if shared_dsid: datastore = manager.open_datastore(shared_dsid) else: datastore = manager.create_datastore() datastore.set_role(Datastore.PUBLIC, Datastore.EDITOR) datastore.commit() print("Shared datastore created (id: %s)." % datastore.get_id())
def dsList(self): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.list_datastores() for ds in result: print(str(ds))
from dropbox.client import DropboxClient, DropboxOAuth2Flow, DropboxOAuth2FlowNoRedirect from dropbox.rest import ErrorResponse, RESTSocketError from dropbox.datastore import DatastoreError, DatastoreManager, Date, Bytes from pprint import pprint import time import os access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') print "Dropbox access token = ", access_token try: client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() manager = DatastoreManager(client) ds = manager.list_datastores() #datastore = manager.open_default_datastore() datastore = manager.open_or_create_datastore('cbr-7') devTable = datastore.get_table('dev1') ir_temps = devTable.query(Type='ir_temperature') values = [] for t in ir_temps: #timeStamp = Date.to_datetime_local(t.get('Date')) timeStamp = float(t.get('Date')) temp = t.get('Data') values.append([timeStamp, temp]) values.sort(key=lambda tup: tup[0]) for v in values: print v[0], v[1]
class DropShell: def __init__(self): self.config = configparser.ConfigParser() self.config.read('dropshell.ini') self.settings = self.config["DropBox"] self.wdPath = [] self.datastoreManager = None def getFilePath(self, fileName): if len(self.wdPath) == 0: return '/' + fileName return '/' + '/'.join(self.wdPath) + '/' + fileName def appAuthorization(self): print('Application authorization required') print('---------------------------------------------------------\n') app_key = self.settings['AppKey'] app_secret = self.settings['AppKeySecret'] flow = dropbox.client.DropboxOAuth2FlowNoRedirect(app_key, app_secret) authorize_url = flow.start() print(' 1. Go to: ' + authorize_url) # "AppName" moechte auf ihren eigenen Ordner Apps > NotesWiki in Ihrer Dropbox zugreifen. # Allow, Deny print(' 2. Click "Allow" (you might have to log in first)') print(' 3. Copy the authorization code.\n') code = input("Enter the authorization code here: ").strip() access_token, user_id = flow.finish(code) # "The access token is all you'll need to make API requests on behalf # of this user, so you should store it away for safe-keeping. # By storing the access token, you won't need to go through these steps # again unless the user reinstalls your app or revokes access via the # Dropbox website." self.settings['UserAccessToken'] = access_token self.settings['UserAccessId'] = user_id with open('dropshell.ini', 'w') as dropshellIni: self.config.write(dropshellIni, False) def processCommand(self, tokens): cmd = tokens[0].lower() if cmd == "quit": self.isRunning = False elif cmd == "connect": self.connect(tokens[1:]) elif cmd == "ls": self.listFiles(tokens[1:]) elif cmd == "cd": self.changeDirectory(tokens[1:]) elif cmd == "info": self.showAccountInfo() elif cmd == "put": self.putFile(tokens[1:]) elif cmd == "get": self.getFile(tokens[1:]) elif cmd == "rm": self.deleteFile(tokens[1:]) elif cmd == "mkdir": self.mkdir(tokens[1:]) elif cmd == "rmdir": self.rmdir(tokens[1:]) elif cmd == "help": self.showHelp() elif cmd == "dscreate": self.dsCreate(tokens[1:]) elif cmd == "dslist": self.dsList() else: print("Syntax error: {}".format(tokens)) def showHelp(self): print(''' Available commands: ------------------- help - Show this help summary connect - Connect to dropbox info - Show information about the connection ls [-l] - Show files and folders in the current folder cd path - Change the current path mkdir folderName - Creates a new folder in the current folder put fileName - Upload a file to the current folder get fileName - Download a file from the current folder rm name - Deletes the specified file or folder from the current folder ds - execute a Datastore API sample quit - Leave the command line client''') def connect(self, parameters): if self.settings.get('useraccesstoken') is None: self.appAuthorization() self.client = dropbox.client.DropboxClient( self.settings['useraccesstoken']) print("Connected.") self.showAccountInfo() def showAccountInfo(self): info = self.client.account_info() print("Connection information") print("-------------------------------") print(' User : {}'.format(info['display_name'])) print(' eMail: {}'.format(info['email'])) print() def listFiles(self, parameters): isLong = len(parameters) > 0 and parameters[0] == '-l' # Depending on the application type / security settings, the # root directory "/" either points to the applications root directory # (e.g. DropBox > Apps > NotesWiki) or to the User's root directory # ("DropBox") wd = '/' + '/'.join(self.wdPath) contents = self.client.metadata(wd) files = contents['contents'] print() for f in files: filePath = f['path'].split('/') fileName = filePath[-1] isDir = f['is_dir'] if isLong: # Www, DD Mmm YYYY HH:MM:SS +Tz mDate = time.strptime(f['modified'], "%a, %d %b %Y %H:%M:%S %z") printDate = time.strftime("%b %d %Y %H:%M:%S", mDate) size = f['size'] print('{:>10} {} {}{}'.format(size, printDate, fileName, '/' if isDir else '')) else: print('{}{}'.format(fileName, '/' if isDir else '')) def changeDirectory(self, parameters): dirName = parameters[0] if dirName == '..': if len(self.wdPath) > 0: self.wdPath = self.wdPath[:-1] else: self.wdPath.append(dirName) def putFile(self, params): remoteFileName = self.getFilePath(params[0]) print("Uploading: {} => {}".format(params[0], remoteFileName)) f = open(params[0], 'rb') response = self.client.put_file(remoteFileName, f) print("Uploaded {} bytes.".format(response['size'])) #f = open('working-draft.txt', 'rb') #response = client.put_file('/magnum-opus.txt', f) #print "uploaded:", response def getFile(self, params): remoteFileName = self.getFilePath(params[0]) print("Downloading: {} => {}".format(remoteFileName, params[0])) out = open(params[0], 'wb') with self.client.get_file(remoteFileName) as f: out.write(f.read()) print("Done.") def mkdir(self, params): remoteDirName = self.getFilePath(params[0]) result = self.client.file_create_folder(remoteDirName) print("Created directory {}".format(result['path'])) #def rmdir(self, params): # remoteDirName = self.getFilePath(params[0]) # result = self.client.file_delete(remoteDirName) # print("Removed directory {}".format(result['path'])) def deleteFile(self, params): remoteFileName = self.getFilePath(params[0]) response = self.client.file_delete(remoteFileName) print("Removed {} {}".format( "directory" if response['is_dir'] else "file", response['path'])) # Datastore API samples def dsCreate(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.open_or_create_datastore(params[0]) print(str(result)) def dsDelete(self, params): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.delete_datastore(params[0], True) print(str(result)) def dsList(self): if self.datastoreManager is None: self.datastoreManager = DatastoreManager(self.client) result = self.datastoreManager.list_datastores() for ds in result: print(str(ds)) def processInput(self): self.connect(None) self.isRunning = True while self.isRunning: wd = '/' + '/'.join(self.wdPath) s = input('[DS] {} > '.format(wd)) tokens = s.split(maxsplit=1) if len(tokens) > 0: self.processCommand(tokens) print()
def webhook(): # Make sure this is a valid request from Dropbox if not bool(os.environ.get('SKIP_VERIFY', 0)): signature = flask.request.headers.get('X-Dropbox-Signature') if signature != hmac.new(os.environ['DROPBOX_APP_SECRET'], flask.request.data, sha256).hexdigest(): flask.abort(403, "X-Dropbox-Signature not match") app.logger.info("data=%s", flask.request.data) if flask.request.data: val = json.loads(flask.request.data) # app.logger.info(data) if 'datastore_delta' in val: for dsupdate in val['datastore_delta']: uid = dsupdate['updater'] # Get deltas for the datastore # datastore.process(uid=uid, handle=change['handle']) # Get content from datastore access_token = models.Token.get_token_value(uid=uid, kind='AccessToken') if access_token: client = DropboxClient(access_token) dsops = _DatastoreOperations(client) dsinfo = models.DatastoreInfo.query.filter_by(handle=dsupdate['handle']).first() rev = dsinfo.last_process_rev if dsinfo else -1 try: resp = dsops.get_deltas(dsupdate['handle'], rev + 1) except DatastoreNotFoundError, e: app.logger.exception(e) app.logger.error("Did you change DROPBOX_APP_SECRET after storing 'AccessToken'?") continue if 'deltas' in resp: deltas = resp['deltas'] # Use only last rev for first time if rev == -1: deltas = deltas[-1:] for delta in deltas: for t, tid, rid, data in [x for x in delta['changes'] if x[0] == 'I']: if tid == 'items': app.logger.info(data['text']) # Safari PUSH notification device_token = models.Token.get_token_value(uid=uid, kind='DeviceToken') if device_token: app.logger.info("deviceToken: %s", device_token) payload = { 'auth_token': os.environ['ZEROPUSH_SAFARI_AUTH_TOKEN'], 'device_tokens[]': [device_token], 'title': 'Item added', 'body': data['text'] } res = requests.post("https://api.zeropush.com/notify", params=payload) app.logger.info(res) # iOS PUSH notification manager = DatastoreManager(client) datastore = manager.open_default_datastore() device_token_table = datastore.get_table('deviceTokens') device_tokens = [r.get_id() for r in device_token_table.query()] app.logger.info("deviceTokens: %s", device_tokens) if device_tokens: payload = { 'auth_token': os.environ['ZEROPUSH_IOS_SERVER_TOKEN'], 'device_tokens[]': device_tokens, 'alert': "Item Added:\n" + data['text'], } app.logger.info(payload) res = requests.post("https://api.zeropush.com/notify", params=payload) app.logger.info(res) rev = delta['rev'] models.DatastoreInfo.upsert(handle=dsupdate['handle'], dsid=dsupdate['dsid'], last_process_rev=rev) models.db.session.commit()
class AnalyseData(): def __init__(self, argv): if len(argv) < 2: print "Usage: checkbridge <bridge>" exit() else: self.bridges = [argv[1]] for b in self.bridges: b = b.lower() print "Checking ", self.bridges access_token = os.getenv('CB_DROPBOX_TOKEN', 'NO_TOKEN') if access_token == "NO_TOKEN": print "No Dropbox access token. You must set CB_DROPBOX_TOKEN environment variable first." exit() try: self.client = DropboxClient(access_token) except: print "Could not access Dropbox. Wrong access token?" exit() self.manager = DatastoreManager(self.client) def niceTime(self, timeStamp): localtime = time.localtime(timeStamp) milliseconds = '%03d' % int((timeStamp - int(timeStamp)) * 1000) now = time.strftime('%Y:%m:%d, %H:%M:%S:', localtime) + milliseconds return now def readData(self): for bridge in self.bridges: print "Reaading and processing data for ", bridge ds = self.manager.open_or_create_datastore(bridge) t = ds.get_table('config') devices = t.query(type='idtoname') self.values = [] devSensors = [] for d in devices: devHandle = d.get('device') devName = d.get('name') t = ds.get_table(devHandle) for sensor in SENSORS: devSensors.append([devName, sensor]) readings = t.query(Type=sensor) for r in readings: timeStamp = float(r.get('Date')) dat = r.get('Data') self.values.append([timeStamp, dat]) def prepareData(self): self.df = {} test = pd.to_datetime([1, 2, 3]) print "test = ", test self.df = pd.DataFrame(self.values) #self.df[t]['epochTime'] = pd.to_datetime(self.df[t]['epochTime'], unit='s') #self.df[t] = self.df[t].set_index('epochTime') #print self.df[t].head() def processTemp(self): self.temp = {} for t in self.tables: print "processTemp, table = ", t self.temp[t] = self.df[t]['ambT'] #print objT.head() print "Mean = ", self.temp[t].mean() self.temp[t] = self.temp[t].resample('10Min') #print objT.head() #objT = objT.cumsum() #objT.plot() #objT = objT.cumsum() #plt.figure(); df.plot(); plt.legend(loc='best') #plt.plot(objT) self.temp[t].plot() plt.ylabel('deg C') plt.show(block=False)