def getTab():
tab = FifoDiskQueue("tab_file")
content = []
t = tab.pop()
while(t != None):
t = t.decode(encoding='UTF-8')
content.append(t)
t = tab.pop()
tab.close()
return json.dumps(content)
def gatherData(username):
sequence = 0
VisitedNodes = set()
queue = FifoDiskQueue("FriendsQueue")
queue.push(username)
sequence += 1
mapToRemoveDuplicates = {username: sequence}
mapUsernameSequence = {username:sequence}
anonymize(username, sequence)
while (queue.__len__()>0):
vertex = queue.pop()
edges = parseFriends(vertex)
VisitedNodes.add(vertex)
count = VisitedNodes.__len__()
if(count <= VertexLimit):
for user in edges:
if not VisitedNodes.__contains__(user):
if (mapToRemoveDuplicates.get(user) == None):
queue.push(user)
sequence += 1
mapToRemoveDuplicates.update({user: sequence})
mapUsernameSequence.update({user:sequence})
anonymize(user, sequence)
else:
exit()
print "Total Visited nodes " + str(count)
saveData(vertex, edges)
anonymizeDataset(vertex, edges, mapUsernameSequence)
def data_download(self):
"""
function for saving data from queue into PdfData table
"""
print("Starting data download")
print("-" * 79)
with self._app.app_context():
while 1:
da_queue = FifoDiskQueue(
os.path.dirname(__file__) + '/../queuedata')
data = da_queue.pop()
da_queue.close()
if not data:
print('sleep for 10')
sleep(10)
#break
else:
raw_data = json.loads(data.decode('utf-8'))
info_log(self.logger.info, "Step1 Save into db Start",
raw_data['reqd_data'])
self._save_pdf_data(raw_data['reqd_data'],
raw_data['tags'],
raw_data['instance_id'])
info_log(self.logger.info, "Step1 Save into db End",
raw_data['reqd_data'])
def pop(queue):
queue = FifoDiskQueue(queue)
async_spec_bytes = queue.pop()
queue.close()
if async_spec_bytes:
return json.loads(async_spec_bytes.decode())
else:
return None
class Thingsspeak(object):
"""docstring for Thingsspeak"""
def __init__(self):
super(Thingsspeak, self).__init__()
self.retry_queue = FifoDiskQueue("/var/thingsspeak.queue")
def send(self, values):
print 'Thingspeak:', values
values = {'created_at': values['created_at'],
'key': 'MYA8R6YDMDQNM9M9',
'field1': values['target_temp'],
'field2': values['current_temp'],
'field3': values['control_value'],
'field4': values['chiller_raw'],
'field5': values['heater_raw'],
'field6': values['current_temp_2']
}
print values
postdata = urllib.urlencode(values)
response_html = self.post_data(postdata)
if response_html != '0':
self.retry()
def retry(self):
if (len(self.retry_queue) > 0):
time.sleep(15)
postdata = self.retry_queue.pop()
print "retrying: ", postdata
if self.post_data(postdata) == 0:
return
#
# 'created_at': self.time,
# 'target_temp': str(self.target_temp),
# 'current_temp': '{0:.3f}'.format(self.current_temp),
# 'control_value': '{0:.0f}'.format(self.control_value),
# 'chiller': self.chiller.get_state_str(),
# 'chiller_info': self.chiller.get_info(),
# 'heater': self.heater.get_state_str(),
# 'heater_info': self.heater.get_info()
def post_data(self, postdata):
target_url = 'https://api.thingspeak.com/update'
request = urllib2.Request(target_url, postdata)
response_html = None
try:
response = urllib2.urlopen(request, None, 5)
response_html = response.read()
response.close()
print response_html
except urllib2.HTTPError, e:
print 'Server could not fulfill the request. Error code: ' + str(e.code)
except urllib2.URLError, e:
print 'Failed to reach server. Reason: ' + str(e.reason)
def run(self):
queue = FifoDiskQueue(self.queue)
while True:
if self.query_cancel():
break
qe = queue.pop()
if qe == None:
break
task = qe.decode('latin1')
os.system(task)
queue.close()
def dataDownload(self):
print("Starting data download")
print("-" * 79)
with self._app.app_context():
while 1:
q = FifoDiskQueue(os.path.dirname(__file__) + '/../queuedata')
data = q.pop()
q.close()
if not data:
print('sleep for 10')
sleep(10)
#break
else:
raw_data = json.loads(data.decode('utf-8'))
self.save_pdf_data(raw_data['reqd_data'], raw_data['tags'])
def tap():
cabinet_id = request.args.get("cabinet_id")
if(cabinet_id is not None):
tab = FifoDiskQueue("tab_file")
current_drink_id = tab.pop()
if(current_drink_id != None):
conn = getdbConn()
drink_id = int(current_drink_id.decode(encoding='UTF-8'))
tab.close()
cursor = conn.execute(getSerachString(drink_id))
ingredients = []
for row in cursor:
ingredients.append({
"name": row[1],
"ratio": row[2]
})
drink = {
"drink_name": row[0],
"ingredients": ingredients
}
response = {"settings":"null","drink":drink}
return json.dumps(response)
return json.dumps({"settings": "null", "drink":"null"})
else:
return json.dumps({'success': False,'error':"Must Have Cabinet ID to access to tap"}), 400, {'ContentType':'application/json'}
import sys
import networkx as nx
from queuelib import FifoDiskQueue
q = FifoDiskQueue("diskFile3")
completed = False
for root, dirs, files in os.walk(sys.argv[1]):
for file in files:
print file
q.push(sys.argv[1] + file)
q.close()
print "-----------------"
while True:
q = FifoDiskQueue("diskFile3")
file1 = q.pop()
file2 = q.pop()
q.close()
if file1 and file2:
print file1
print file2
fileId1 = "_".join(file1.split("_")[1:5]).split(".")[0]
fileId2 = "_".join(file2.split("_")[1:5]).split(".")[0]
newFileId = sys.argv[2] + "_" + fileId1 + "_" + fileId2 + ".gpickle"
print newFileId
G1 = nx.read_gpickle(file1)
G2 = nx.read_gpickle(file2)
G1.add_nodes_from(G2.nodes(data=True))
G1.add_edges_from(G2.edges(data=True))
nx.write_gpickle(G1, newFileId)
APP_KEY = api_keys.APP_KEY
APP_SECRET = api_keys.APP_SECRET
OAUTH_TOKEN = api_keys.OAUTH_TOKEN
OAUTH_TOKEN_SECRET = api_keys.OAUTH_TOKEN_SECRET
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
selfies = ['1.png', '2.png', '3.png']
q = FifoDiskQueue("queuefile")
if len(q) == 0:
for selfie in selfies:
q.push(selfie)
selfie = q.pop()
q.close()
@sched.scheduled_job('interval', minutes=10)
def revolve_avatar():
avatar = open("selfies/" + selfie, 'rb')
twitter.update_profile_image(image=avatar)
@sched.scheduled_job('cron', day_of_week='mon-sun', hour=5)
def evolve_banner():
twitter.update_profile_banner_image(banner=image)
sched.start()
def pop(self):
return self.unmarshal(FifoDiskQueue.pop(self))
