def Selecionar():
print('Informe o tipo de Consulta: C - COMPLETA | A - ATUALIZAÇÃO: ',
end='')
tipo = str(input())
print('Informe a Data INICIAL para a Consulta [YYYY-MM-DD]: ', end='')
data_inicio = str(input())
print('Informe a Data FINAL para a Consulta [YYYY-MM-DD]: ', end='')
data_final = str(input())
selecao = Selector(
) #Faz a seleção do conteudo dos tweets e insere em Banco de dados.
selecao.select(tipo, data_inicio, data_final)
class Learn(object):
def __init__(self, topic, user):
self.topic = topic
self.user = user
self.user_loc = user.replace(
'@',
'__at__',
).replace('.', '__dot__')
self.items = get_items_fb(['items', topic])
self.resp_sub_loc = ['response', topic, self.user_loc]
res = Firebase.get_df(FB_URL, self.resp_sub_loc, False)
self.responses = pd.DataFrame.from_dict(res, orient='index')
self.item_selector = Selector(self.items)
def evalute(self, item, response):
correct = remove(item.answer) == remove(response)
ts = time.time()
ts_str = datetime.datetime.now().replace(microsecond=0).isoformat()
store = {ts_str: {'ts': ts, 'key': item.key, 'correct': correct}}
Firebase.update(FB_URL, self.resp_sub_loc, store)
self.responses = pd.concat([self.responses, pd.DataFrame(store).T])
return correct
def next(self):
item = self.item_selector.select(self.responses, method='basic_prob')
response = input('\n' + item.question + ': ')
correct = self.evalute(item, response)
if correct:
print("correct")
else:
print("incorrect: " + item.answer)
def calculate():
room_key = str(request.form['room_key'])
user_name = str(request.form['user_name'])
if redis.client.hexists(room_key, 'outcome') == False:
if (redis.client.hlen(room_key) != 0) & (redis.client.hget(
room_key, 'host')['user_name'] == user_name):
user_selector = Selector(redis.client.hgetall(room_key))
redis.client.hmset(room_key, {'outcome': user_selector.select()})
else:
msg = {
'Data Processing, please revisit the page later. Thanks for your patience.'
}
return json.dumps(msg)
class Eventloop(object):
instance = None
def __init__(self):
self._ready = []
self._scheduled = []
self._selector = Selector()
self._stopping = False
@classmethod
def get_current_loop(cls):
if Eventloop.instance is None:
Eventloop.instance = cls()
return Eventloop.instance
def call_soon(self, callback):
self._ready.append(Handle(self, callback))
def call_later(self, delay, callback):
when = datetime.utcnow() + timedelta(seconds=delay)
self._scheduled.append(TimerHandle(when, self, callback))
def run_forever(self):
while True:
self.run_once()
if self._stopping:
break
def run_once(self):
event_list = self._selector.select()
if event_list:
for _, handle in event_list:
self._ready.append(handle)
ready = [item for item in self._scheduled if item.is_ready()]
for item in ready:
self._scheduled.remove(item)
self._ready.extend(ready)
for handle in self._ready:
handle.run()
self._ready = []
def run_until_complete(self, future):
task = self.create_task(future)
task.add_done_callback(self.stop)
self.run_forever()
def stop(self):
self._stopping = True
def create_future(self):
return Future(loop=self)
def create_task(self, coro):
return Task(coro, self)
async def listen_io(self, ioid):
fut = self.create_future()
self._selector.register(
ioid, Handle(self, partial(self._recv_io, fut, ioid)))
#fut.add_done_callback()
listen_io(ioid, fut)
return await fut
def _recv_io(self, fut, ioid):
res = recv_io(ioid)
fut.set_result(res)
