def send_warning(user_id, message, seconds): """ Sends Timing warning to user for specified amount of time """ print 'in send warning' time.sleep(seconds - 2) print 'after sleep' ut.send_response(message + str(seconds) + ' seconds.', user_id)
def create_payment():
form = PaymentForm()
if form.validate_on_submit():
payment = request.get_json()
if not is_exists_invoices(invoice_list=[
payment['number_invoice_provider'],
payment['number_invoice_reciever']
]):
return send_response(
content={'message': 'Invoices does not exists'},
status_code=404)
key = get_payment_key()
code_confirm = randint(100, 1000)
db.session.add(
Payment(key=key,
amount_money=payment['amount_money'],
number_invoice_provider=payment['number_invoice_provider'],
number_invoice_reciever=payment['number_invoice_reciever'],
code_confirm=code_confirm,
status_id=1))
db.session.commit()
send_code_confirm_payment_to_client(code=code_confirm)
return send_response(content={'message': 'ok'}, status_code=200)
return send_response(content=form.errors, status_code=400)
def set(user, user_id, text):
muscle_groups = defaultdict(list)
text_muscles = [x.strip() for x in re.split(',|and',text) if x.strip()]
#=====[ Check to see if each item in text matches against a muscle group ]=====
for muscle in text_muscles:
#=====[ Checks for individual muscles: e.g. lats, traps]=====
if muscle in muscles:
muscle_groups['specific'].append(muscle)
#=====[ Checks for muscle groups: e.g. back, legs ]=====
elif muscle in grouped_muscles:
muscle_groups['group'].append(muscle)
#=====[ If no muscle groups found, inform user of possible muscle groups to specify ]=====
if not len(muscle_groups):
ut.send_response(GOAL_EXERCISES, user_id)
return
#=====[ Update user object ]=====
user.goals = muscle_groups
for key in user.goals.keys():
print key
for key2 in user.goals[key]:
print key2
ut.update(user_id, user)
message = UPDATED_GOALS + ', '.join(user.goals['specific'])
message += ', ' + ', '.join(user.goals['group']) if user.goals['group'] else ''
ut.send_response(message, user_id)
def respond(message, user): """ Step 1: Extracts relevant info from user message Step 2: Evaluate user status Step 3: send appropriate response """ try: status = user.status if command.process(user, message): return if status == "intro": intro.process(user, message) elif status == "idle": idle.process(user, message) elif status == "workout": workout_log.process(user, message) elif status == "feedback": feedback.process(user, message) #=====[ If error caught, send user an error message and keep in same state ]===== except Exception as e: print e ut.send_response(ERROR_MESSAGE, user_id)
def end_user_workout(user, user_id, workout): print 'in end workout' #=====[ Clear process timers to remind user to start next set ]===== clear_timers(user) #=====[ Record current workout and end time. Update user ]===== if workout.end(): ut.send_response(END_WORKOUT_MESSAGE, user_id) #=====[ Send workout summary, stats, and spider chart ]===== ut.send_response(workout.get_summary(), user_id) ut.send_response(workout.get_stats(), user_id) ut.send_response(workout.summarize_muscle_groups(4), user_id) #=====[ Add workout to list of past workouts and put in idle mode ]===== user.add_workout(workout) else: user.current_workout = None user.status = 'idle' ut.update(user_id, user) ut.send_response(NO_WORKOUT_LOGGED, user_id) ut.update(user_id, user)
def register_me(route_id):
try:
response = requests.get(SESSIONS_SERVICE_URL + 'identify/',
headers=clean_hh(request))
if response.status_code != 200:
return send_error(request, 403)
except ConnectionError:
return send_response(request, {'status': 'Session service is down'})
user = response.json()['data']
print({'USER': user})
headers = {}
headers.update({
'X_EMAIL': user['email'],
'X_SECRET': user['password'],
})
print({'HEADERS': headers})
try:
response = requests.post(ROUTE_SERVICE_URL +
'route/%s/register/' % route_id,
headers=headers)
if response.status_code == 200:
return send_response(request, {'status': 'OK'})
return send_error(request, response.status_code)
except ConnectionError:
return send_response(request, {'status': 'Route service is down'})
def personal_view():
try:
response = requests.get(SESSIONS_SERVICE_URL + 'identify/',
headers=clean_hh(request))
if response.status_code != 200:
return send_error(request, 403)
except ConnectionError as e:
return send_response(request, {'status': 'Session service is down'})
user = response.json()['data']
headers = {'X_EMAIL': user['email']}
try:
response = requests.get(COMPANY_SERVICE_URL + 'companies/',
headers=headers)
if response.status_code == 200:
companies = json.loads(response.text)
user['companies'] = companies['data']
except ConnectionError as e:
user['companies'] = {'error': 'Company service is down'}
try:
response = requests.get(ROUTE_SERVICE_URL + 'my_routes/',
headers=headers)
if response.status_code == 200:
routes = json.loads(response.text)
user['routes'] = routes['data']
except ConnectionError as e:
user['routes'] = {'error': 'Routes service is down'}
return send_response(request, {'status': 'OK', 'data': user})
def register_view(route_id):
"""
curl -X post 'http://127.0.0.1:9093/route/586f9570050df411919ca465/register/' -H 'X_EMAIL: [email protected]' -H 'X_SECRET: ewifyw521763eyuwfgeuwYTWDYA'
"""
idid = int(route_id)
if not idid:
return send_error(request, 404)
email = request.headers.environ.get('HTTP_X_EMAIL')
if not email:
return send_error(request, 404)
route = mongo.db.route.find({'self_id': idid})
if route.count() == 0:
return send_error(request, 404)
route = cursor_to_list(route)[0]
users_on_route = route.get('users', [])
if email not in users_on_route:
users_on_route.append(email)
result = mongo.db.route.update_one({'self_id': idid},
{'$set': {
'users': users_on_route
}})
return send_response(request, {
'status': 'OK',
'updated': result.matched_count
})
else:
return send_response(request, {'status': 'OK', 'updated': 0})
def start(user): user_id = user.get_id() #=====[ Start workout ]===== user.status = "feedback" user.status_state = 0 ut.update(user_id, user) ut.send_response(FEEDBACK_QUESTION, user_id)
def subroutine_intro(self, user_id): sub_state = self.workout_state[0] subroutine = self.template.workout.subroutines[sub_state] response = 'Subroutine is:\n' for exercise in subroutine.exercises: response += exercise + '\n' ut.send_response(response, user_id)
def get_route_view(route_id):
"""
curl -X get 'http://127.0.0.1:9093/route/586f956f050df411919ca464'
curl -X delete 'http://127.0.0.1:9093/route/586f956f050df411919ca464'
"""
idid = int(route_id)
if not idid:
return send_error(request, 404)
if request.method == 'GET':
route = mongo.db.route.find({'self_id': idid})
route = cursor_to_list(route)
print({'method': 'get', 'route': route})
if len(route) > 0:
return send_response(request, route[0])
else:
return send_error(request, 404)
elif request.method == 'PATCH':
#TODO: check company owner
json_s = request.get_json(force=True)
print(json_s)
json_d = json.loads(json_s)
print({"jayson": json_d})
if json_d is None:
return send_error(request, 400)
# route = {field: json_d[field] for field in ROUTE_FIELDS if json_d[field] is not None}
route = {}
for field in ROUTE_FIELDS:
if field in json_d:
value = json_d[field]
if value is not None:
route.update({field: value})
print({'method': 'patch', 'route': route})
if len(route) == 0:
return send_error(request, 400)
route['updated'] = datetime.now()
result = mongo.db.route.update({'self_id': idid}, {'$set': route})
return send_response(request, {
'status': 'OK',
'updated': result['nModified']
})
elif request.method == 'DELETE':
#TODO: check company owner
result = mongo.db.route.delete_one({'self_id': idid})
return send_response(request, {
'self_id': idid,
'deleted': result.deleted_count
})
def show_balance_invoice(num):
try:
invoice = Invoice.query.filter_by(num=num).first()
return send_response(content={
'message': 'ok',
'balance': str(invoice.balance)
},
status_code=200)
except (KeyError, AttributeError):
return send_response(
content={'message': 'Number invoice does not exists'},
status_code=404)
def __init__(self, user_id, workout_template): self.workout = Workout() print 'templates' self.template = pickle.loads(templates.find_one()['template_object']) print 'after templates' self.state = NOT_STARTED self.workout_state = None self.prev_user_set = None self.template.intro = 'Chest and Triceps' ut.send_response(self.template.intro, user_id) ut.send_response(START_WORKOUT, user_id)
def confirm_payment():
req = request.get_json()
payment = Payment.query.filter_by(
number_invoice_provider=req['invoice'],
code_confirm=req['code_confirm']).scalar()
if payment:
return send_response(content={
'message': 'ok',
'key': payment.key
},
status_code=200)
return send_response(content={'message': 'Invalid code'}, status_code=400)
def access_token_view():
grant_type = request.form.get('grant_type')
code = request.form.get('code')
if grant_type.lower() != 'authorization_code' or not code:
return send_error(request, 400)
app = extract_client(request, OAUTH2_APPS)
grant = mongo.db.OAuth2Code.find({
'app': app['client_id'],
'token': code,
'expires': {
'$gt': datetime.now()
}
})
if grant.count() == 0:
return send_error(request, 404)
grant = cursor_to_list(grant)[0]
token = {
'expires': datetime.now() + timedelta(seconds=36000),
'access_token': generate_token(),
'refresh_token': generate_token(),
'token_type': 'Bearer',
'user': grant['user'],
}
mongo.db.OAuth2Access.insert(token)
mongo.db.OAuth2Code.delete_one({'token': code, 'app': app['client_id']})
token['expires'] = 36000
return send_response(request, token)
def login_view():
if request.method == 'GET':
auth = session.get('email')
if auth:
return render_template('yet_auth.html', email=auth)
return render_template('login.html', url=request.url)
elif request.method == 'POST':
email = request.form.get('email')
password = request.form.get('password')
if not email or not password:
return send_error(request, 400)
password = get_hash(password.encode('ascii')).hexdigest()
users_cursor = mongo.db.user.find({
'email': email,
'password': password
})
if users_cursor.count() == 0:
return send_error(request, 404)
user = cursor_to_list(users_cursor)[0]
session['email'] = user['email']
if 'next' in request.args:
redirect_uri = unquote(request.args.get('next'))
return redirect(redirect_uri)
return send_response(request, {'status': 'Authorized'})
def process_video(video_path, fps):
video_frames = get_frames(video_path, fps)
face_img_queue = mp.Queue()
video_preds_queue = mp.Queue()
face_detection_process = mp.Process(target=run_retinaface,
args=(video_frames, face_img_queue))
face_detection_process.start()
video_face_imgs = face_img_queue.get()
face_detection_process.join()
emotion_detection_process = mp.Process(target=run_emotion_net,
args=(video_face_imgs,
video_preds_queue))
emotion_detection_process.start()
video_frame_preds = video_preds_queue.get()
emotion_detection_process.join()
print('Video Successfully Processed')
pred_dict = to_dict(video_frame_preds)
r = send_response(pred_dict)
if (r.status_code == 200):
print("Predictions succesfully posted.")
return video_frame_preds
def process(user, message): user_id, text = ut.get_info(user, message) if "start" in text and "workout" in text: #=====[ Start guided workout ]===== if "guided" in text: workout_template = True workout_log.start(user, workout_template) #=====[ Manually log workout ]===== else: workout_log.start(user) #=====[ Send default message ]===== else: ut.send_response(DEFAULT_IDLE_MESSAGE, user_id)
def process_request(connection, peer_info, request):
utils.Logging.debug("Entering peer.process_request")
if request.command == "RFCQuery":
data = handle_rfcs_query(peer_info.rfc_index_head)
status = "200"
utils.send_response(connection, records.P2PResponse(status, data))
elif request.command == "GetRFC":
if "rfc" in request.data:
metadata = read_rfc_metadata()
if metadata:
rfc = None
for rfc_meta in metadata["rfcs"]:
if rfc_meta["number"] == request.data["rfc"]:
rfc = rfc_meta
break
rfc_file = get_rfc_path(rfc)
if rfc and os.path.exists(rfc_file):
utils.send_rfc(connection, rfc_file, rfc["format"])
else:
status = "100"
data = {
"message":
"Requested RFC %s not found" % request.data["rfc"]
}
utils.send_response(connection,
records.P2PResponse(status, data))
else:
status = "100"
data = {
"message":
"Requested RFC %s not found" % request.data["rfc"]
}
utils.send_response(connection,
records.P2PResponse(status, data))
else:
data = {"message": "Received GetRFC request without rfc field"}
status = "300"
utils.send_response(connection, records.P2PResponse(status, data))
else:
data = {"message": "Request message has an invalid command"}
status = "300"
utils.send_response(connection, records.P2PResponse(status, data))
def auth():
try:
api_key = request.get_json()['api_key']
except KeyError:
return send_response(
content={'message': 'Not sended api_key'},
status_code=400
)
if not api_key:
return send_response(
content={'message': 'Api key required'},
status_code=401
)
if not is_valid_api_key(api_key=api_key):
return send_response(
content={'message': 'Api key is not valid'},
status_code=401
)
def my_routes_view():
email = request.headers.environ.get('HTTP_X_EMAIL')
print(request.headers)
print(email)
if not email:
return send_error(request, 403)
routes = mongo.db.route.find({'users': email})
routes = cursor_to_list(routes)
return send_response(request, {'status': 'OK', 'data': routes})
def generate_spider(user_id, muscles):
""" Generates a spider chart showing user's muscle_groups """
values = muscles.values()
values = [int(100*val/sum(values)) for val in values]
labels = muscles.keys()
#=====[ If just one muscle was worked, return to user with simple message ]=====
if len(values) == 1:
ut.send_response('Seems like you worked out a lot of ' + labels[0], user_id)
return False
#=====[ set font, linestyle, and fit parameters for chart ]=====
font_size = 6
label_font_size = 8
matplotlib.rcParams.update({'font.size': font_size})
matplotlib.rcParams.update({'figure.autolayout': True})
plt.rc('grid', color='k', linewidth=1, linestyle=':',alpha=0.25)
#=====[ Instantiate polar plot ]=====
N = len(labels)
theta = radar_factory(N, frame='circle')
fig = plt.figure(figsize=(3,3))
ax = fig.add_subplot(1,1,1,projection='radar')
#=====[ Plot values, ideal values, and set labels ]=====
ax.plot(theta, values, color='b')
ax.fill(theta, values, color='b',alpha = 0.25)
ax.set_varlabels(labels)
ax.set_yticklabels([])
#=====[ Get x,y locations for setting labels on spider chat ]=====
radians = np.arange(np.pi/2,np.pi*9/4,np.pi*2/len(values))
#=====[ Added percentage labels to each macro nutrient ]=====
for idx, val in enumerate(values):
ax.text(radians[idx],val + 5, str(val) + '%', fontsize=label_font_size,ha='center',va='center',color='k')
fig.savefig('spider.png',dpi=300)
return True
def start(user, workout_template=None): """ Initializes users workout fields """ user_id = user.get_id() user.time = datetime.datetime.now() user.status ="workout" #=====[ Updates user status state depending on whether workout is guided for free, manual entry ]===== if workout_template: user.status_state = GUIDED_WORKOUT user.workout_guider = WorkoutGuider(user_id, workout_template) #=====[ START GUIDED WORKOUT ]===== else: user.current_workout = Workout() user.status_state = FREE_WORKOUT ut.send_response(START_WORKOUT_MESSAGE, user_id) ut.update(user_id, user)
def main():
config = utils.load_config(args.config)
head = None
# sock = utils.listen4clients((utils.get_ip_address(), config["rs"]["port"]))
sock = utils.listen4clients(
(config["rs"]["hostname"], config["rs"]["port"]))
last_time_updated = int(time.time())
# Serve incoming connections
while True:
try:
utils.Logging.info(records.display_swarm_table(head))
connection, request = utils.accept_request(sock)
periodic_ttl_reduction(head, last_time_updated)
head, response = process_request(head, request)
last_time_updated = int(time.time())
utils.send_response(connection, response)
except KeyboardInterrupt:
utils.Logging.exit("Registration server shutting down")
break
sock.close()
def routes_view():
"""
curl -X get 'http://127.0.0.1:9093/routes/?size=2&page=1'
"""
try:
routes = mongo.db.route.find({}).sort('created', DESCENDING)
result = paginate(request, data=routes)
return send_response(request, result)
except Error as e:
return send_error(request, e.code)
def create_company_view():
"""
curl -X POST -H "Content-Type: application/json" 'http://127.0.0.1:9092/company/' \
-d '{"abbreviation": "TTS", "name": "Transport Travel System", "info": null, "user": "******"}'
"""
#TODO: create with owner
json_s = request.get_json()
if json_s is None:
return send_error(request, 400)
json_d = json.loads(json_s)
if json_d is None:
return send_error(request, 400)
company = {field: json_d.get(field) for field in COMPANY_FIELDS}
found = mongo.db.company.find({'abbreviation': company['abbreviation']}).count()
if found > 0:
return send_response(request, {'status': 'Such abbr already exists'})
company['created'] = datetime.now()
mongo.db.company.insert(company)
return send_response(request, {'status': 'OK', 'data': company})
def get_company_view(abbr):
"""
curl -X GET 'http://localhost:9092/company/TTS/'
curl -X PATCH -d '{"info": "Hello"}' -H "Content-Type: application/json" 'http://127.0.0.1:9092/company/TTS/'
curl -X DELETE 'http://localhost:9092/company/TTS/'
"""
if request.method == 'GET':
company = mongo.db.company.find({'abbreviation': abbr})
company = cursor_to_list(company)
print({'method': 'get', 'company': company})
if len(company) > 0:
return send_response(request, company[0])
else:
return send_error(request, 404)
elif request.method == 'PATCH':
#TODO: check owner
json_s = request.get_json()
if json_s is None:
return send_error(request, 400)
json_d = json.loads(json_s)
if json_d is None:
return send_error(request, 400)
company = {field: json_d.get(field) for field in COMPANY_FIELDS if field in json_d}
if len(company) == 0:
return send_error(request, 400)
company['updated'] = datetime.now()
result = mongo.db.company.update_one({'abbreviation': abbr}, {'$set': company})
return send_response(request, {'status': 'OK', 'updated': result.modified_count})
elif request.method == 'DELETE':
#TODO: check owner
result = mongo.db.company.delete_one({'abbreviation': abbr})
return send_response(request, {'abbreviation': abbr, 'deleted': result.deleted_count})
def companies_view():
"""
curl -X GET 'http://localhost:9092/companies/?size=2&page=2'
"""
find_params = {}
email = request.headers.environ.get('HTTP_X_EMAIL')
if email:
find_params['user'] = email
try:
companies = mongo.db.company.find(find_params).sort('created', DESCENDING)
result = paginate(request, data=companies)
return send_response(request, result)
except Error as e:
return send_error(request, e.code)
def create_route_view():
"""
curl -X POST -H "Content-Type: application/json" 'http://127.0.0.1:9093/route/' \
-d '{"name": "North Russia", "departure": "2015-10-10 12:00:00", "arrival": "2015-10-15 18:00:00", "price": 100, "company": "TTS"}'
"""
#TODO: check company owner
json_s = request.get_json(force=True)
json_d = json.loads(json_s)
if json_d is None:
return send_error(request, 400)
#route = {field: request.json.get(field) for field in ROUTE_FIELDS}
route = {}
for field in ROUTE_FIELDS:
if field in json_d:
value = json_d[field]
if value is not None:
route.update({field: value})
else:
route.update({field: None})
if route['company'] is None:
return send_error(request, 404)
response = requests.get(COMPANY_SERVICE_URL + 'company/' +
route['company'])
if response.status_code == 404:
return send_error(request, 404)
route['created'] = datetime.now()
# max_response = mongo.db.route.find().sort({'self_id': -1}).limit(1)
max_response = mongo.db.route.find({}, {'self_id': 1})
print({'max_response': max_response})
if max_response.count() == 0:
route['self_id'] = int(1)
else:
max_id = 1
for r in max_response:
if r['self_id'] > max_id:
max_id = r['self_id']
route['self_id'] = int(max_id) + 1
mongo.db.route.insert(route)
return send_response(request, {'status': 'OK', 'data': route})
def process(self, text, user, user_id):
"""
Processes user input for a given state
state = NOT_STARTED ---> ask user to start
state = IN_WORKOUT ---> log current set reported by user
Returns bool representing successful parse and whether we should move on to next set
"""
#=====[ If user has not started workout ]=====
if self.state == NOT_STARTED:
if 'yes' in text:
#=====[ hard coding timers for now ]=====
self.template.workout.timer = [45, 60]
user.timer = self.template.workout.timer
ut.update(user_id, user)
self.state = IN_WORKOUT
self.workout_state = (0, -1)
return (True, True)
else:
ut.send_response(START_WORKOUT,user_id)
return (False, False)
#=====[ If in workout, log state ]=====
elif self.state == IN_WORKOUT:
sub_state, set_state = self.workout_state
user_set = ut.extract_exercise(text)
if user_set:
template_workout = self.template.workout
sub_state, set_state = self.workout_state
xsets = template_workout.subroutines[sub_state].get_flattened_sets()
user_set.exercise = xsets[set_state].exercise
#=====[ Log set and give feedback ]=====
workout_log.log_set(user_set, self.workout, user, user_id)
ut.send_response('Got your last set to be: ' + str(user_set), user_id)
self.prev_user_set = user_set
return (self.cur_set_feedback(user_set, xsets[set_state], user_id), True)
else:
ut.send_response('Exercise not recognized, please retry', user_id)
return (False, False)
def identify_view():
auth_header = request.headers.environ.get('HTTP_AUTHORIZATION', '')
if not auth_header.startswith('Bearer'):
return send_error(request, 403)
token = auth_header[7:]
grant = mongo.db.OAuth2Access.find({
'access_token': token,
'expires': {
'$gt': datetime.now()
}
})
if grant.count() == 0:
return send_error(request, 403)
grant = cursor_to_list(grant)[0]
user_cursor = mongo.db.user.find({'email': grant['user']})
if user_cursor.count() != 1:
return send_error(request, 403)
user_data = cursor_to_list(user_cursor)[0]
return send_response(request, {'status': 'OK', 'data': user_data})
def login():
if session.get('user_id'):
return send_response({'message':'you are already logged in'})
auth = request.authorization
if auth:
username = auth.username
password = auth.password
user = current_app.db.users.find_one({'username':username})
if user:
if current_app.bcrypt.check_password_hash(user['password'], password):
session['user_id'] = user['user_id']
return send_response({'message':'login successful'})
else:
return send_response({'message':'wrong passphrase'},status=400)
else:
if not username:
return send_response({'message':'provide a username'},status=400)
else:
return send_response({'message':'unknown user "{0}"'.format(username)},status=400)
else:
return send_response({'message':'username and password required'},status=400)
def process(user, message):
user_id, text = ut.get_info(user, message)
#==========[ Command used to list all super commands for the workout logger ]==========#
# #
# usage: " list commands " #
# #
########################################################################################
if ('list' in text and 'commands' in text) or text == 'ls':
ut.send_response('Here are a list of commands:\n\n' + '\n'.join(command_list.keys()), user_id)
#=====[ Command used to log thoughts/improvements while using the workout logger ]=====#
# #
# usage: " sudo log: [suggestion to improve] " #
# #
########################################################################################
elif 'sudo' in text and 'log' in text and ':' in text:
with open('to_improve_log','a') as f:
f.write(text.split(':')[1].strip() + '\n\n')
ut.send_response(MESSAGE_LOGGED, user_id)
############################################################################
############################################################################
#################TODO TODO TODO TODO TODO TODO TODO#########################
####################IMPLEMENT LISTING WORKOUTS##############################
############################################################################
elif 'list' in text and 'template' in text and 'workouts' in text:
saved_workouts = '1. Chest Gains | Sets: 24\nTime: 1 hour\nMuscles: Chest, Triceps\n\n2. Ab Attack | Sets: 15\nTime: 20 minutes\nMuscles: Abs, Obliques\n\n3. Leg Day | Sets: 28\nTime: 1 hour 20 minutes\nMuscles: Quads, Hamstrings, Calves'
ut.send_response(saved_workouts, user_id)
#=========================[ Command used list recent workouts ]========================#
# #
# usage: " list workouts " #
# #
########################################################################################
elif 'list' in text and 'workouts' in text:
ut.send_response('\n'.join([str(idx + 1) + '. ' + str(workout) for idx, workout in enumerate(reversed(user.workouts))]), user_id)
#=====================[ Command used to review most recent workout ]===================#
# #
# usage: " review last workout " #
# #
########################################################################################
elif 'review' in text and 'last' in text and 'workout' in text:
workout = user.workouts[-1]
ut.send_response(workout.get_summary(), user_id)
ut.send_response(workout.get_stats(),user_id)
ut.send_response(workout.summarize_muscle_groups(4), user_id)
# index = index if len(workout.muscle_groups) >= index else len(workout.muscle_groups)
# if generate_spider(user_id, dict(workout.muscle_groups.most_common(index))):
# ut.send_response('Check out the muscles you targeted:\nfile:///Users/Brandon/Desktop/Projects/workout_logger/spider.png', user_id)
#==================[ Command used to review a particular workout ]=====================#
# #
# usage: " review workout: [index] " #
# #
########################################################################################
elif 'review' in text and 'workout' in text:
try:
idx = int(ut.extract_int(text))
workout = user.workouts[-idx]
ut.send_response(user.workouts[-idx].get_summary(), user_id)
ut.send_response(user.workouts[-idx].get_stats(), user_id)
ut.send_response(workout.summarize_muscle_groups(4), user_id)
# index = 4 if len(workout.muscle_groups) > 3 else len(workout.muscle_groups)
# if generate_spider(user_id, dict(workout.muscle_groups.most_common(index))):
# ut.send_response('Check out the muscles you targeted:\nfile:///Users/Brandon/Desktop/Projects/workout_logger/spider.png', user_id)
except Exception as e:
print e
#==================[ Command used to remove a particular workout ]=====================#
# #
# usage: " remove workout: [index] " #
# #
########################################################################################
elif 'remove' in text and 'workout' in text:
try:
idx = int(ut.extract_int(text))
workout = user.workouts[-idx]
ut.send_response('Deleted workout: ' + str(workout), user_id)
del user.workouts[-idx]
ut.update(user_id, user)
except Exception as e:
print e
#=============[ Command used to review a weeks worth of workout stats ]================#
# #
# usage: " review week " #
# #
########################################################################################
elif 'review' in text and 'week' in text:
info = 'Here\'s your week in review: \n\n'
info += 'Total Volume: ' + str(user.get_volume(7)) + '\n'
info += 'Total Sets: ' + str(user.get_num_sets(7)) + '\n'
info += 'Total Time: ' + "{0:.2f}".format(float(user.get_total_set_time(7)/3600.0)) + ' hours' + '\n'
info += 'Avg. Set Time: ' + "{0:.2f}".format(user.get_avg_set_time(7)) + '\n'
ut.send_response(info, user_id)
ut.send_response(user.get_muscle_groups(7, 7), user_id)
if hasattr(user, 'goals'):
goal.review(user, user_id, 7, 7)
# index = 6 if len(workout.muscle_groups) > 5 else len(workout.muscle_groups)
# if generate_spider(user_id, dict(user.get_muscle_groups(7).most_common(index))):
# ut.send_response('Check out the muscles you targeted most:\nfile:///Users/Brandon/Desktop/Projects/workout_logger/spider.png', user_id)
elif 'q:' in text or 'query:' in text:
exercise = text.split(':')[1].strip()
info = 'You queried for: %s\n\n' % exercise
print 'before query'
sets = user.query_exercise(exercise)
print 'after query'
if sets:
for date in sets:
workout_sets = sets[date]
info += "Workout on %s:\n" % date
for xset in workout_sets:
info += "%s reps of %s @ %s\n" % (xset.reps, xset.exercise, xset.weight)
ut.send_response(info, user_id)
else:
ut.send_response("Sorry, I couldn't find any sets of " + exercise, user_id)
#==================[ Command used to drop a user from the database ]===================#
# #
# usage: " reset db " #
# #
########################################################################################
elif text == 'reset db':
ut.send_response('BYE FOREVER! :( ', user_id)
ut.remove_user(user_id)
#==================[ Command used set goals for targeted muscles ]=====================#
# #
# usage: " set goals: muslce1, muscle2, muscle3" #
# #
########################################################################################
elif 'set' in text and 'goal' in text:
muscle_groups = text.split(':')
#=====[ Check to make sure there are muscle groups specified after a colon ]=====
if len(muscle_groups) == 1:
ut.send_response(SET_GOALS, user_id)
#=====[ set goals for user ]=====
goal.set(user, user_id, muscle_groups[1])
#================[ Command used set timers at specified intervals ]====================#
# #
# usage: " set timer for 45 and 60 seconds" #
# #
########################################################################################
elif 'set' in text and 'timer' in text:
times = re.split(',|and',text)
found_time = False
#=====[ Checks each comma separated value for a time ]=====
for time_candidate in times:
time = extract_int(time_candidate)
#=====[ If time for timer extracted, save info ]=====
if time:
found_time = True
if hasattr(user,'timer'):
user.timer.append(time)
else:
user.timer = [time]
#=====[ Tell user how to set timer ]=====
if not found_time:
ut.send_response(HOW_TO_SET_TIMER, user_id)
else:
ut.send_response(SET_TIMER + ', '.join([str(x) for x in user.timer]) + ' seconds', user_id )
ut.update(user_id, user)
#========================[ Command used to clear all timers ]==========================#
# #
# usage: " clear timer " #
# #
########################################################################################
elif 'clear' in text and 'timer' in text:
user.timer = []
ut.send_response(CLEARED_TIMER, user_id)
ut.update(user_id, user)
#========================[ Command used to exit to idle mode ]=========================#
# #
# usage: " exit " #
# #
########################################################################################
elif text == 'exit':
user.status = 'idle'
ut.send_response(IDLE_MODE, user_id)
ut.update(user_id, user)
#=====================[ Command used to get help for any command ]=====================#
# #
# usage: " help [command] " #
# #
########################################################################################
elif 'help' in text:
user_command = text.replace('help','').strip()
#=====[ Check if user command is in our command shortcut list. If so, send appropriate help response ]=====
for command in command_shortcuts:
if user_command in command_shortcuts[command]:
ut.send_response(command_list[command], user_id)
return True
#=====[ Tell user that we couldn't find specified command and send list of commands ]=====
ut.send_response(HELP_COMMAND, user_id)
ut.send_response('Here are a list of commands:\n\n' + '\n'.join(command_list.keys()), user_id)
#===================[ Command used to learn how to log a workout ]=====================#
# #
# usage: " how to log?" | "how do I log a workout? " #
# #
########################################################################################
elif 'how' in text and 'log' in text:
user.status = "intro"
user.status_state = 1
intro.process(user, message, instructions=True)
#==========================[ Command used to greet user ]==============================#
# #
# usage: Greet Tony: 'Hi' #
# #
########################################################################################
elif text in greetings:
ut.send_response(GREETING, user_id)
elif 'thank' in text:
ut.send_response(NO_PROBLEM, user_id)
ut.send_response(np.random.choice(INSPIRATIONAL),user_id)
else:
return False
return True
valid_to_str, "%d/%m/%Y").replace(
tzinfo=pytz.utc)
valid_to_out = hh_format(valid_to)
pt = sess.query(MeterType).filter(
MeterType.code == code).first()
if pt is None:
yield ','.join(
(
'"' + str(v) + '"' for v in (
'insert', 'meter_type', code, description,
valid_from_out, valid_to_out))) + "\n"
elif (description, valid_from, valid_to) != (
pt.description, pt.valid_from, pt.valid_to):
yield ','.join(
(
'"' + str(v) + '"' for v in (
'update', 'meter_type', code, description,
valid_from_out, valid_to_out))) + "\n"
else:
raise Exception("The table " + table + " is not recognized.")
finally:
if sess is not None:
sess.close()
utils.send_response(
inv, content, file_name=table + '_' + version + '_general_import.csv')
else:
raise UserException("HTTP method not recognized.")
def next_set(self, user_id): sub_state, set_state = self.workout_state # Get the subroutine of the current set curr_subroutine = self.template.workout.subroutines[sub_state] set_state += 1 if set_state >= curr_subroutine.num_sets: set_state = 0 sub_state += 1 if sub_state >= len(self.template.workout.subroutines): return None # Update curr_subroutine after updating indexes curr_subroutine = self.template.workout.subroutines[sub_state] sets_per_cycle = len(curr_subroutine.exercises) subroutine_mode = curr_subroutine.mode # Update object workout state self.workout_state = (sub_state, set_state) # set_state == 0 means we are starting a new subroutine if set_state == 0: self.subroutine_intro(user_id) self.workout.add_subroutine() next_subroutine = self.template.workout.subroutines[sub_state] self.workout.new_subroutine(next_subroutine.mode, next_subroutine.exercises) # If we are at the beginning of a cycle in a circuit if subroutine_mode == "circuit" and set_state % sets_per_cycle == 0: response = "Next Cycle of Circuit: \n" sets = self.template.workout.subroutines[sub_state].get_flattened_sets() for i in range(sets_per_cycle): xset = sets[set_state + i] response += xset.exercise + ' ' + str(xset) + "\n" ut.send_response(response, user_id) # TODO: FOR BRANDON # get_feedback - current user set, current template set, next template set (None for diff subroutine) response = "Your next set is: " sets = self.template.workout.subroutines[sub_state].get_flattened_sets() xset = sets[set_state] response += xset.exercise + ' ' + str(xset.reps) + " reps\n" message = True #=====[ Give feedback for up and coming set ]===== if self.prev_user_set: message = self.next_set_feedback(self.prev_user_set, xset, user_id) ut.send_response(response, user_id) print 'message to return is:', message print self.workout_state print set_state if self.workout_state: return (message, False) if set_state != 0 else (message, True) else: return (self.workout_state, False)
if hh_before(era.finish_date, finish_date):
chunk_finish = era.finish_date
else:
chunk_finish = finish_date
yield imp_mpan_core_str + ',' + exp_mpan_core_str + ',' + \
hh_format(chunk_start) + ',' + hh_format(chunk_finish) + ','
supply_source = computer.SupplySource(
sess, chunk_start, chunk_finish, forecast_date, era, is_import,
None, caches)
supply_source.contract_func(contract, 'virtual_bill')(
supply_source)
bill = supply_source.dc_bill
for title in bill_titles:
yield '"' + str(bill.get(title, '')) + '",'
if title in bill:
del bill[title]
keys = bill.keys()
keys.sort()
for k in keys:
yield ',"' + k + '","' + str(bill[k]) + '"'
yield '\n'
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='hhdc_vbs.csv')
def review(user, user_id, days=7, num_muscles=7):
""" Provides feedback on muscles targeted over the past week """
#=====[ Get muscle groups and target muscle groups ]=====
values, labels = user.get_muscle_groups(days, num_muscles, False)
target_muscles = user.goals
#=====[ Initialize holders ]=====
summary = ''
not_targeted = []
barely_targeted = []
not_targeted_groups = defaultdict(list)
barely_targeted_groups = defaultdict(list)
#=====[ Get indices of muscles that have been heavily focused on ]=====
focus_idxs = [idx for idx, val in enumerate(values) if val > 30]
if focus_idxs:
ut.send_response("You've focused heavily on " + ', '.join([labels[idx] for idx in focus_idxs]), user_id)
#=====[ Check to see if each specific target muscle has been worked out and, if it has, to what degree ]=====
for muscle in target_muscles['specific']:
if muscle not in labels:
not_targeted.append(muscle)
else:
idx = labels.index(muscle)
if values[idx] < 10:
barely_targeted.append(muscle)
#=====[ Check to see which (if any) specific target muscles within specified larger muscle groups have been worked out,
#=====[ and, if they have, to what degree
for muscle_group in target_muscles['group']:
for muscle in grouped_muscles[muscle_group]:
if muscle not in labels:
not_targeted_groups[muscle_group].append(muscle)
else:
idx = labels.index(muscle)
if values[idx] < 10:
barely_targeted_groups[muscle_group].append(muscle)
#=====[ Formulate muscle review message for specific muscles ]=====
message = ''
for muscle in not_targeted:
message += 'You have not targeted ' + ', '.join(not_targeted) + ' at all. '
for muscle in barely_targeted:
message += 'You have not focused much on ' + ', '.join(barely_targeted) + '. '
#=====[ Send update for specific muscles ]=====
if message:
ut.send_response(message, user_id)
message = ''
#=====[ Formulate muscle review message for muscle groups ]=====
for muscle_group in not_targeted_groups:
message += "You wanted to focus on " + muscle_group + ", but you have not worked out " + ', '.join(not_targeted_groups[muscle_group]) + '. '
for muscle_group in barely_targeted_groups:
message += "For " + muscle_group + ", you've barely worked out " + ', '.join(barely_targeted_groups[muscle_group]) + '. '
if message:
ut.send_response(message, user_id)
elif cur_sup is not None and \
prev_sup is not None and cur_sup != prev_sup:
add_event(
events, era.start_date, "Change Of Supplier", None,
mpan_core)
prev_era = era
if len(events) > 0:
site = sess.query(Site).join(SiteEra).filter(
SiteEra.is_physical == true(),
SiteEra.era == last_era).one()
for event in events:
vals = [
event['mpan-core'], site.code, site.name,
event['date'].strftime("%Y-%m-%d %H:%M"),
event['code']]
yield '\n' + ','.join(
'"' + str(val) + '"' for val in vals) + ','
else:
yield ' '
except:
yield traceback.format_exc()
finally:
sess.close()
utils.send_response(
inv, content, status=200, mimetype='text/csv',
file_name='output.csv')
def method_not_allowed(e):
return send_response(content={'message': 'Method not allowed'},
status_code=405)
else:
metering_type = 'nhh'
for group in site.groups(sess, start_date, finish_date, True):
for supply in group.supplies:
sources.add(supply.source.code)
generator_type = supply.generator_type
if generator_type is not None:
generator_types.add(generator_type.code)
for hh in group.hh_data(sess):
for stream in streams:
totals[stream] += hh[stream]
assoc_str = ','.join(sorted(list(assoc)))
sources_str = ','.join(sorted(list(sources)))
generators_str = ','.join(sorted(list(generator_types)))
yield ','.join('"' + str(v) + '"' for v in (
site.code, site.name, assoc_str, sources_str, generators_str,
start_date.strftime("%Y-%m-%d %H:%M"),
finish_date.strftime("%Y-%m-%d %H:%M"), totals['imp_net'],
totals['displaced'], totals['exp_net'], totals['used'],
totals['exp_gen'], totals['imp_gen'], metering_type)) + '\n'
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='sites_duration.csv')
sorted(
set(
sup.generator_type.code for sup in
group.supplies
if sup.generator_type is not None)))
group_start_str = hh_format(group.start_date)
group_finish_str = hh_format(group.finish_date)
for hh in group.hh_data(sess):
hh_start = hh['start_date']
if hh_start.hour == 0 and hh_start.minute == 0:
yield "\r\n" + \
','.join(
'"' + str(val) + '"' for val in [
site.code, site.name, associates,
source_codes, gen_types,
group_start_str, group_finish_str,
'used', hh_start.strftime('%Y-%m-%d')])
used_gen_kwh = hh['imp_gen'] - hh['exp_net'] - \
hh['exp_gen']
used_3p_kwh = hh['imp_3p'] - hh['exp_3p']
used_kwh = hh['imp_net'] + used_gen_kwh + used_3p_kwh
yield ',' + str(round(used_kwh, 2))
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(
inv, content, status=200, mimetype=mime_type, file_name=file_name)
"",
era.pc.code,
"",
era.mtc.code,
"",
llfc.code,
"",
ssc,
"",
supplier_contract.party.participant.code,
"",
dc,
"",
mop,
"",
supply.gsp_group.code,
"",
msn,
"",
meter_type,
"In Chellow, but not in ECOES.",
]
)
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name="output.csv")
None)
disp_func(site_ds)
bill = site_ds.supplier_bill
for title in bill_titles:
if title in bill:
val = bill[title]
if isinstance(val, datetime.datetime):
val = hh_format(val)
else:
val = str(val)
yield ',"' + val + '"'
del bill[title]
else:
yield ',""'
keys = bill.keys()
keys.sort()
for k in keys:
yield ',"' + k + '","' + str(bill[k]) + '"'
yield '\n'
month_start += relativedelta(months=1)
month_finish = month_start + relativedelta(months=1) - HH
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='displaced.csv')
@import url(https://fonts.googleapis.com/css?family=Overclock);
table {
border: thin solid gray;
border-collapse: collapse;
}
td {
border: thin solid gray;
padding-left: 0.2em;
padding-right: 0.2em;
}
th {
border: thin solid gray;
}
#title {
font-size: xx-large;
}
.logo {
color: green;
}
body {
line-height: 1.2;
font-size: 0.9em;
font-family: 'Overclock', sans-serif;
background-color: rgb(255, 236, 139);
}
'''
utils.send_response(inv, content, 200, mimetype='text/css')
#!/usr/bin/env python
import cgitb; cgitb.enable()
import sys
import os
sys.path.append(os.path.dirname(__file__))
import utils
from utils import Headers
#utils.send_response('test')
origin = os.environ.get('HTTP_ORIGIN', '*')
headers = Headers()
headers['Access-Control-Allow-Origin'] = origin
headers['Access-Control-Allow-Credentials'] = 'true'
headers['Set-Cookie'] = 'sessionid=1234'
headers['Set-Cookie'] = 'sessionid2=5678; HttpOnly'
html = """
Please enter your name:
<input type="text" id="name" />
<button onclick="document.cookie='name='+document.getElementById('name').value;location.reload()">Save</button>
"""
if utils.get_cookie('name'):
html = "Hello %s" % (utils.get_cookie('name') or 'nobody')
utils.send_response(html, headers)
def process(user, message, instructions=False): """ Introduces a user to the workout chatbot and to logging workouts """ user_id, text, status_state = ut.get_info(user, message, True) if status_state == 0: #=====[ Send introduction messages to user ]===== ut.send_response(WELCOME_MESSAGE, user_id) ut.send_response(COMMAND_INTRO, user_id) ut.send_response(WORKOUT_INTRO, user_id) user.status_state = 1 #=====[ Begins teaching a user how to log a workout ]===== elif status_state == 1: #=====[ Check if user said yes to learning about working out ]===== for word in yes_words: if word in text: instructions = True break if instructions: #=====[ Send instructions for starting workout, logging sets, and ask if they want to learn about logging circuits ]===== ut.send_response(WORKOUT_START_INSTRUCTIONS, user_id) ut.send_response(WORKOUT_SET_INITIALIZATION, user_id) ut.send_response(WORKOUT_SET_CONTINUATION, user_id) ut.send_response(LEARN_ABOUT_CIRCUITS, user_id) user.status_state = 2 else: user.status = "idle" user.status_state = 0 ut.send_response(DONE_INSTRUCTIONS, user_id) #=====[ Processes message when user is learning about logging workouts. Currently, just checks to see if user wants to learn #=====[ about logging circuits ]===== elif status_state == 2: user_id, text = ut.get_info(user, message) #=====[ Check if user gave a 'yes' word. If so gives information about logging circuits ]===== for word in yes_words: if word in text: #=====[ Teach user how to log circuits ]===== ut.send_response(WORKOUT_CIRCUIT_INITIALIZATION, user_id) ut.send_response(WORKOUT_CIRCUIT_CONTINUATION, user_id) ut.send_response(ASK_SEE_EXAMPLE, user_id) user.status_state = 3 elif status_state == 3: #=====[ Update user into idle mode regardless of whether they wish to learn about circuits or not ]===== user.status = "idle" user.status_state = 0 ut.update(user_id, user) #=====[ Check if user gave a 'yes' word. If so gives information about logging circuits ]===== for word in yes_words: if word in text: #=====[ Teach user how to log circuits ]===== ut.send_response(WORKOUT_EXAMPLE, user_id) return #=====[ Checks if user gave a 'no' word ]===== for word in no_words: if word in text: ut.send_response(DONE_INSTRUCTIONS, user_id) return #=====[ If no 'yes' or 'no' word found, then just assume user doesn't want to learn about logging circuits ]===== ut.send_response(ASSUME_DONE_INSTRUCTIONS, user_id) #=====[ update user (primarily state) in db ]===== ut.update(user_id, user)
Monad.getUtils()['impt'](globals(), 'db', 'utils', 'templater')
inv = globals()['inv']
def content():
sess = None
try:
sess = db.session()
yield "Supply Id, Note Index, Category, Is Important?, Body\n"
for supply in sess.query(db.Supply).order_by(db.Supply.id):
try:
supply_note = eval(supply.note)
except SyntaxError:
continue
for i, note in enumerate(supply_note['notes']):
vals = [
supply.id, i, note['category'], note['is_important'],
note['body']]
vals = map(unicode, vals)
for i, val in enumerate(vals):
vals[i] = val.replace('"', '""')
yield ','.join('"' + v + '"' for v in vals) + '\n'
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='notes.csv')
yield ','.join('"' + str(value) + '"' for value in [
data_source.mpan_core, site.code, site.name,
data_source.supplier_account,
hh_format(data_source.start_date),
hh_format(data_source.finish_date)])
computer.contract_func(
caches, contract, 'virtual_bill', None)(data_source)
bill = data_source.supplier_bill
for title in bill_titles:
if title in bill:
val = str(bill[title])
del bill[title]
else:
val = ''
yield ',"' + val + '"'
for k in sorted(bill.keys()):
yield ',"' + k + '","' + str(bill[k]) + '"'
yield '\n'
month_start += relativedelta(months=1)
month_finish = month_start + relativedelta(months=1) - HH
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='virtual_bills.csv')
def exchange_format():
if not request.is_json:
return send_response(
content={'message': 'Not valid format data. Need JSON!'},
status_code=400
)
ss.mpan_core, site.code, site.name, ss.supplier_account,
hh_format(ss.start_date), hh_format(ss.finish_date)])
computer.contract_func(
caches, sup_con, 'virtual_bill', None)(ss)
bill = ss.supplier_bill
for title in bill_titles:
if title in bill:
val_raw = bill[title]
if isinstance(val_raw, datetime.datetime):
val = hh_format(val_raw)
else:
val = str(val_raw)
yield ',"' + val + '"'
del bill[title]
else:
yield ',""'
for k in sorted(bill.keys()):
yield ',"' + k + '","' + str(bill[k]) + '"'
yield '\n'
day_start += relativedelta(days=1)
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name='daily_supplier_virtual_bill.csv')
Snag.start_date < cutoff_date).order_by(
Site.code, Supply.id, Channel.imp_related,
Channel.channel_type, Snag.description,
Snag.start_date, Snag.id):
snag_start = snag.start_date
snag_finish = snag.finish_date
if snag_finish is None:
snag_finish_str = ''
duration = now - snag_start
age_of_snag = datetime.timedelta(0)
else:
snag_finish_str = snag_finish.strftime("%Y-%m-%d %H:%M")
duration = snag_finish - snag_start
age_of_snag = now - snag_finish
yield ','.join('"' + str(val) + '"' for val in [
days_hidden, snag.id, era.imp_mpan_core, era.exp_mpan_core,
site.code, site.name, snag.description, channel.imp_related,
channel.channel_type, snag_start.strftime("%Y-%m-%d %H:%M"),
snag_finish_str,
age_of_snag.days + float(age_of_snag.seconds) / (3600 * 24),
duration.days + float(duration.seconds) / (3600 * 24),
snag.is_ignored]) + '\n'
except:
yield traceback.format_exc()
finally:
if sess is not None:
sess.close()
utils.send_response(inv, content, file_name=file_name)
def process(user, message): user_id, text = ut.get_info(user, message) workout = user.get_last_workout() rating = extract_int(text) print rating #On feedback question if user.status_state == 0: if "yes" in text or "ok" in text: ut.send_response(RATING_QUESTION, user_id) user.status_state = 1 elif "no" in text: ut.send_response(NO_FEEDBACK, user_id) user.status = "idle" user.status_state = 0 else: ut.send_response(FEEDBACK_CLARIFY, user_id) ut.send_response(FEEDBACK_QUESTION, user_id) ut.update(user_id, user) # On rating question elif user.status_state == 1: if rating: if rating >= 1 and rating <= 10: workout.rating = rating ut.send_response(QUESTION_END, user_id) user.status_state = 2 ut.update(user_id, user) ut.send_response(DIFFICULTY_QUESTION, user_id) return # If anything goes wrong, send a clarifying message ut.send_response(RATING_CLARIFY, user_id) ut.send_response(RATING_QUESTION, user_id) # On difficulty question elif user.status_state == 2: if rating: if rating >= 1 and rating <= 5: workout.rating = rating ut.send_response(QUESTION_END, user_id) user.status_state = 3 ut.update(user_id, user) ut.send_response(TIREDNESS_QUESTION, user_id) return # If anything goes wrong, send a clarifying message ut.send_response(DIFF_TIRED_CLARIFY, user_id) ut.send_response(DIFFICULTY_QUESTION, user_id) # On tiredness question elif user.status_state == 3: if rating: if rating >= 1 and rating <= 5: workout.rating = rating ut.send_response(FEEDBACK_END, user_id) user.status = "idle" user.status_state = 0 ut.update(user_id, user) return # If anything goes wrong, send a clarifying message ut.send_response(DIFF_TIRED_CLARIFY, user_id) ut.send_response(TIREDNESS_QUESTION, user_id)