def create_intake():
req = request.get_json()
m_id = req['medicine_id']
p_date = req['planned_date_time']
a_date = req['actual_date_time']
i_status = 3
if a_date is not None and len(a_date)>0:
i_status = hp.get_intake_status(p_date, a_date)
if i_status != 3:
PredictionService.confirm_intake(m_id, dateparser.parse(a_date))
cur_intake = Intake(med_id=m_id,
actual_date=a_date,
planned_date=p_date,
intake_status=i_status)
cur_session = Session()
prev_intake = cur_session.query(Intake).filter(Intake.med_id == m_id).filter(Intake.planned_date == p_date).first()
if prev_intake is not None:
prev_intake.actual_date = cur_intake.actual_date
prev_intake.intake_status = cur_intake.intake_status
else:
cur_session.add(cur_intake)
cur_session.commit()
cur_session.close()
return INTAKE_ADD_SUCCESS
def test_add():
app.testing = True
prediction_service = PredictionService()
response = app.test_client().post(
'/classify',
data=json.dumps({
"jsonrpc": "2.0",
"method": "classify",
"params": {
"Pclass": 1,
"Sex": "female",
"Age": 34,
"SibSp": 1,
"Parch": 0,
"Embark": "S"
},
"id": "1"
}),
content_type='application/json',
)
data = json.loads(response.get_data(as_text=True))
assert "id" in data
assert "probability" in data
assert response.status_code == 200
def test_feature_processing3():
passenger = {
"Pclass": 1,
"Sex": "female",
"SibSp": 2,
"Parch": 2,
"Embark": "Q"
}
processed_passenger = PredictionService.process_features(passenger)
assert processed_passenger["Age"] == None
assert processed_passenger["sex"] == 0
assert processed_passenger["deck"] == None
assert processed_passenger["embarked"] == 2
def test_feature_processing2():
passenger = {
"Pclass": 1,
"Sex": "female",
"Age": 15,
"SibSp": 2,
"Parch": 2,
"Embark": "S",
"Cabin": "B105"
}
processed_passenger = PredictionService.process_features(passenger)
assert processed_passenger["sex"] == 0
assert processed_passenger["deck"] == 2
assert processed_passenger["embarked"] == 1
from prediction_service import PredictionService
ps = PredictionService()
#print(imgs.getImageVector())
#ps.trainModel("./Dataset/extracted_images/")
ps.predict("./TestData/test2.jpg")
def reset_config():
global hp
hp = Helpers(app)
Q_service.start_service(hp)
PredictionService.start_service(Session, hp)
return CONFIG_RESET_SUCCESS
# Create SQL engine, session-factory object and create all tables
# These are my own credentials for my local MySql Server, you need
# to use your own server credentials when running locally or use
# in memory sqlite - create_engine('sqlite:///:memory:', echo = True)
db_user = hp.get_config('db', 'user')
db_pass = hp.get_config('db', 'password')
db_name = hp.get_config('db', 'name')
db_port = str(hp.get_config('db', 'port'))
sql_engine = create_engine('mysql+pymysql://'+db_user+':'+db_pass+'@localhost:'+db_port+'/'+db_name,
pool_recycle=3600,
echo=True)
Session = sessionmaker(bind=sql_engine)
Base.metadata.create_all(sql_engine)
PredictionService.start_service(Session, hp)
Q_service.start_service(hp)
ACTION_WINDOW = hp.get_config('model', 'action_window')
API_KEY = hp.get_config('basic', 'api_key')
AUTHORIZED_USER = hp.get_config('basic', 'authorized_user')
SECURE_SERVER = hp.get_config('basic', 'security')
# Standard responses
ENTRY_NOT_FOUND = ('', 204)
DEVICE_ALREADY_REGISTERED = ('Device already registered with same push_id', 200)
DELETE_SUCCESS = ('Deletion complete', 200)
USER_ALREADY_EXISTS = ('Patient already exists with same patient Id', 500)
USER_ADD_SUCCESS = ('Patient Added Successfully', 201)
USER_ADD_FAILED = ('Failed to add patient', 400)
USER_DOES_NOT_EXIST = ('The specified patient does not exist', 400)
import logging
# pylint: disable=import-error
from app_config import training_service_config, mlflow_models_mapping, service_config
from prediction_service import PredictionService
prediction_service = PredictionService(training_service_config,
mlflow_models_mapping, service_config)
if __name__ == '__main__':
logging_level = service_config['log_level']
log = logging.getLogger('werkzeug')
log.setLevel(logging_level)
prediction_service.run_flask_server(port=service_config['port'],
host='0.0.0.0')
from flask import Flask, request, jsonify
from marshmallow import ValidationError
from passenger import PassengerSchema
from prediction_service import PredictionService
app = Flask(__name__)
prediction_service = PredictionService()
@app.route('/classify', methods=["POST"])
def classify():
data = request.get_json()
# initial vaalidation of request fields
try:
passenger = PassengerSchema().load(data["params"])
passenger["id"] = data["id"]
except ValidationError as err:
return (err.messages)
response_object = prediction_service.predict(passenger)
return jsonify(response_object)
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
def dispatch(med_id, u_id, start):
Q_service.helper.logger.debug('Dispatch initiated for medicine id: %s',
str(med_id))
total_data = Q_service.med_data[med_id]
times = Q_service.med_timestamps[med_id]
touches = Q_service.med_touches[med_id]
SLIDE_WINDOW = Q_service.SLIDE_WINDOW
T_WINDOW = Q_service.T_WINDOW
D, S, A = Q_service.med_data[med_id].shape
dispatch_data = Q_service.helper.get_clean_data_array((D, S, A))
disp_cap_data = []
for d in range(D):
for s in range(S):
if (len(times[d, s]) == 0): # no data for this sensor
continue
s_time = times[d, s][0]
#Q_service.helper.logger.debug("s_time, d,s,times[d,s] :%s,%s, %s, %s", s_time, d, s, times[d,s])
del_idx, send_idx = get_index(times[d,
s], s_time + SLIDE_WINDOW,
s_time + T_WINDOW)
if send_idx == 0:
Q_service.helper.logger.debug(
'Not enough data to dispatch!')
return
for a in range(A):
dispatch_data[d, s, a] = copy.deepcopy(
total_data[d, s, a][:send_idx - 1])
Q_service.med_data[med_id][
d, s, a] = Q_service.med_data[med_id][d, s,
a][del_idx:]
Q_service.helper.logger.debug(
"sensor data del_idx, send_idx : %s, %s", del_idx,
send_idx)
Q_service.med_timestamps[med_id][
d, s] = Q_service.med_timestamps[med_id][d, s][del_idx:]
#Q_service.helper.logger.debug('Calling predict for medicine id : %s ', str(dispatch_data))
# Optimize this later
touch_ts = [k[1] for k in touches
] # timestamps extracted from list of tuples
del_idx, send_idx = get_index(touch_ts, touches[0][1] + SLIDE_WINDOW,
touches[0][1] + T_WINDOW)
if send_idx == 0:
Q_service.helper.logger.debug(
'Not enough capacitive data to dispatch!')
return
Q_service.helper.logger.debug("Cap data del_idx, send_idx : %s, %s",
del_idx, send_idx)
Q_service.med_touches[med_id] = Q_service.med_touches[med_id][del_idx:]
disp_cap_data = Q_service.med_touches[med_id][:send_idx - 1]
PredictionService.predict(med_id, u_id, dispatch_data, disp_cap_data,
start)