def api_add():
data = request.get_json()
age = data['age']
height = data['height']
weight = data['weight']
gender = data['gender']
s_blood_pressure = data['s_blood_pressure']
d_blood_pressure = data['d_blood_pressure']
cholesterol = data['cholesterol']
glucose = data['glucose']
smoking = data['smoking']
alcohol = data['alcohol']
physical = data['physical']
prediction = data['prediction']
predicted_username = data['predicted_username']
new_entry = Entry(age=age,
gender=gender,
height=height,
weight=weight,
s_blood_pressure=s_blood_pressure,
d_blood_pressure=d_blood_pressure,
cholesterol=cholesterol,
glucose=glucose,
smoking=smoking,
alcohol=alcohol,
physical=physical,
prediction=prediction,
predicted_on=datetime.utcnow(),
predicted_username=predicted_username)
result = add_entry(new_entry)
return jsonify({'id': result})
def predict():
# get data from drawing canvas and save as image
img_dir = parseImage(request.get_data())
# Decoding and pre-processing base64 image
img = image.img_to_array(
image.load_img(img_dir + 'output.png',
color_mode="grayscale",
target_size=(48, 48))) / 255.
# reshape data to have a single channel
img = img.reshape(1, 48, 48, 1)
predictions = make_prediction(img)
for i, pred in enumerate(predictions):
label_pred = "{}".format(labels[np.argmax(pred)])
new_entry = Entry(
image_name=timezone.localize(datetime.now()).strftime("%d %B %Y, ") +
label_pred + " by " + session['username'],
prediction=label_pred,
username=session['username'],
predicted_on=timezone.localize(datetime.now()))
add_entry(new_entry)
response = []
for i in predictions[0]:
response.append(i)
ret = ""
for i, pred in enumerate(predictions):
ret = "{}".format(labels[np.argmax(pred)])
response.append(ret)
return jsonify(response)
def test_EntryClassFail(entrylist, capsys):
with capsys.disabled():
now = datetime.datetime.utcnow()
new_entry = Entry(age=entrylist[0],
height=entrylist[1],
weight=entrylist[2],
gender=entrylist[3],
s_blood_pressure=entrylist[4],
d_blood_pressure=entrylist[5],
cholesterol=entrylist[6],
glucose=entrylist[7],
smoking=entrylist[8],
alcohol=entrylist[9],
physical=entrylist[10],
prediction=entrylist[11],
predicted_on=now)
assert new_entry.age == entrylist[0]
assert new_entry.height == entrylist[1]
assert new_entry.weight == entrylist[2]
assert new_entry.gender == entrylist[3]
assert new_entry.s_blood_pressure == entrylist[4]
assert new_entry.d_blood_pressure == entrylist[5]
assert new_entry.cholesterol == entrylist[6]
assert new_entry.glucose == entrylist[7]
assert new_entry.smoking == entrylist[8]
assert new_entry.alcohol == entrylist[9]
assert new_entry.physical == entrylist[10]
assert new_entry.prediction == entrylist[11]
assert new_entry.predicted_on == now
def _render_tag(self, entry_name, caller):
entry = Entry.query.filter_by(name=entry_name).first()
if not entry:
entry = Entry()
entry.name = entry_name
db.session.add(entry)
db.session.commit()
return entry.value if entry.value else '[%s]' % entry.name
def predict():
form = PredictionForm()
if request.method == 'POST':
if form.validate_on_submit():
age = form.age.data
height = form.height.data
weight = form.weight.data
gender = int(form.gender.data)
s_blood_pressure = form.s_blood_pressure.data
d_blood_pressure = form.d_blood_pressure.data
cholesterol = int(form.cholesterol.data)
glucose = int(form.glucose.data)
smoking = int(form.smoking.data)
alcohol = int(form.alcohol.data)
physical = int(form.physical.data)
# Engineer feature engineered columns
bmi = weight / ((height / 100)**2)
avg_bp = (s_blood_pressure + d_blood_pressure) / 2
X = [[
age, gender, height, weight, s_blood_pressure,
d_blood_pressure, cholesterol, glucose, smoking, alcohol,
physical, bmi, avg_bp
]]
result = ai_model.predict(X)
probability = round(
ai_model.predict_proba(X)[0][int(result[0])] * 100, 2)
new_entry = Entry(age=age,
gender=gender,
height=height,
weight=weight,
s_blood_pressure=s_blood_pressure,
d_blood_pressure=d_blood_pressure,
cholesterol=cholesterol,
glucose=glucose,
smoking=smoking,
alcohol=alcohol,
physical=physical,
prediction=int(result[0]),
predicted_on=datetime.utcnow(),
predicted_username=current_user.username)
add_entry(new_entry)
if result[0] == 0:
flash(
f"Prediction: {display_result[result[0]]}, Probability: {probability}%",
"success")
else:
flash(
f"Prediction: {display_result[result[0]]}, Probability: {probability}%",
"danger")
else:
flash("Error, cannot proceed with prediction", "danger")
return render_template("index.html",
title="Enter Parameters",
form=form,
index=True,
entries=get_entries())
def test_log_with_valid_fields():
entry = Entry()
entry.content = 'content is all there is'
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'log'
log_entry.entry = entry
entry.save()
def test_entry_type_must_be_in_models_schema():
entry = Entry()
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'catfish'
log_entry.entry = entry
with pytest.raises(ValidationError):
log_entry.save()
def test_feedback_with_invalid_fields():
entry = Entry()
entry.yikes = 'not good!'
log_entry = LogEntry()
log_entry.entry_type = 'feedback'
log_entry.entry = entry
with pytest.raises(ValidationError):
log_entry.save()
def test_objective_with_valid_fields():
entry = Entry()
entry.how = 'this is how'
entry.what = 'this is what'
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'objective'
log_entry.entry = entry
log_entry.save()
def test_log_with_invalid_fields():
entry = Entry()
entry.foo = 'this is not right there is no foo'
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'log'
log_entry.entry = entry
with pytest.raises(ValidationError):
log_entry.save()
def test_objective_with_invalid_fields():
entry = Entry()
entry.how = 'this is how'
entry.what = 'this is what'
entry.something_not_right = 'this is not right'
with pytest.raises(ValidationError):
log_entry = LogEntry()
log_entry.entry_type = 'objective'
log_entry.entry = entry
log_entry.save()
def test_EntryClassFail(entrylist, capsys):
with capsys.disabled():
now = datetime.datetime.utcnow()
new_entry = Entry(image_name=entrylist[0],
prediction=entrylist[1],
username=entrylist[2],
predicted_on=now)
assert new_entry.image_name == entrylist[0]
assert new_entry.prediction == entrylist[1]
assert new_entry.username == entrylist[2]
assert new_entry.predicted_on == now
def add():
if request.method == 'POST':
form = request.form
title = form.get('title')
description = form.get('description')
if not title or description:
entry = Entry(title = title, description = description)
db.session.add(entry)
db.session.commit()
return redirect('/')
return "of the jedi"
def test_save_log_entry_with_content():
entry = Entry()
entry.content = 'content is all there is'
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'log'
log_entry.entry = entry
log_entry.save()
from_db = LogEntry.objects(id=log_entry.id).get()
assert from_db.entry.content == 'content is all there is'
assert from_db.entry_type == 'log'
def test_feedback_with_valid_fields():
entry = Entry()
entry.requested_from = '*****@*****.**'
entry.requested_by = '*****@*****.**'
entry.details = 'details'
entry.share_objectives = True
entry.sent = True
entry.replied = True
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'feedback'
log_entry.entry = entry
log_entry.save()
def test_save_log_entry_with_objective():
entry = Entry()
entry.how = 'this is how'
entry.what = 'this is what'
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'objective'
log_entry.entry = entry
log_entry.save()
from_db = LogEntry.objects(id=log_entry.id).get()
assert from_db.entry_type == 'objective'
assert from_db.entry.how == 'this is how'
assert from_db.entry.what == 'this is what'
def api_add():
data = request.get_json()
image_name = data['image_name']
prediction = data['prediction']
username = data['username']
new_entry = Entry(image_name=image_name,
prediction=prediction,
username=username,
predicted_on=timezone.localize(datetime.now()))
#invoke the add entry function to add entry
result = add_entry(new_entry)
#return the result of the db action
return jsonify({'id': result})
def test_save_log_entry_with_feedback():
entry = Entry()
entry.requested_from = '*****@*****.**'
entry.requested_by = '*****@*****.**'
entry.details = 'details'
entry.share_objectives = True
entry.sent = True
entry.replied = True
entry.save()
log_entry = LogEntry()
log_entry.entry_type = 'feedback'
log_entry.entry = entry
log_entry.save()
from_db = LogEntry.objects(id=log_entry.id).get()
assert from_db.entry_type == 'feedback'
assert from_db.entry.requested_from == '*****@*****.**'
assert from_db.entry.requested_by == '*****@*****.**'
assert from_db.entry.details == 'details'
assert from_db.entry.share_objectives
assert from_db.entry.sent
assert from_db.entry.replied
