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 __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 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
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 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 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))
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))
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]
def connect(self):
manager = DatastoreManager(self.api_client)
self.datastore = manager.open_default_datastore()
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)
