def lookup_user(self, user_id):
"""lookup_user
:param user_id: user id
"""
lookup_user_data = {"user_id": user_id}
# if Celery is enabled use it
task_method = task_get_user
if settings.CELERY_ENABLED:
task_method = task_get_user.delay
task_name = "get_user"
user_res = run_task(task_method=task_method,
task_name=task_name,
req_data=lookup_user_data,
get_result=True)
return user_res
def create(self, request, validated_data):
"""create
Start a new MLJob
:param request: http request
:param validated_data: post dictionary
"""
last_step = ""
data = {}
res = {
"status": FAILED,
"code": drf_status.HTTP_400_BAD_REQUEST,
"error": "not run",
"data": data
}
try:
user_id = request.user.id
log.info(("{} create user_id={} data={}").format(
self.class_name, user_id, validated_data))
# if the Full Stack is running with Celery
# then it is assumed the task will be published
# to the worker and only the MLJob and MLJobResult
# records will be returned for polling the status
# of the long-running training job
task_name = "ml_job"
get_result = True
ml_job_task = task_ml_job
if settings.CELERY_ENABLED:
ml_job_task = task_ml_job.delay
get_result = False
req_data = validated_data
req_data["user_id"] = user_id
create_res = create_ml_job_record(req_data=req_data)
user_obj = create_res.get("user_obj", None)
ml_job_obj = create_res.get("ml_job_obj", None)
ml_result_obj = create_res.get("ml_result_obj", None)
if not user_obj:
res["error"] = ("{} - Failed to find User").format(task_name)
res["status"] = ERR
res["code"] = drf_status.HTTP_400_BAD_REQUEST
res["error"] = create_res.get("err", "error not set")
res["data"] = None
log.error(res["error"])
return res
if not ml_job_obj:
res["error"] = (
"{} - Failed to create MLJob").format(task_name)
res["status"] = ERR
res["code"] = drf_status.HTTP_400_BAD_REQUEST
res["error"] = create_res.get("err", "error not set")
res["data"] = None
log.error(res["error"])
return res
if not ml_result_obj:
res["error"] = (
"{} - Failed to create MLJobResult").format(task_name)
res["status"] = ERR
res["code"] = drf_status.HTTP_400_BAD_REQUEST
res["error"] = create_res.get("err", "error not set")
res["data"] = None
log.error(res["error"])
return res
req_data["user_data"] = {
"id": user_obj.id,
"email": user_obj.email,
"username": user_obj.username
}
req_data["ml_job_data"] = ml_job_obj.get_public()
req_data["ml_result_data"] = ml_result_obj.get_public()
job_res = run_task(task_method=ml_job_task,
task_name=task_name,
req_data=req_data,
get_result=get_result)
log.info(("task={} res={}").format(task_name, str(job_res)[0:30]))
# in sync mode the data is in the task
# response object, so send it back
# because the client is blocking on it
if job_res["status"] == SUCCESS:
res = {
"status": SUCCESS,
"code": drf_status.HTTP_201_CREATED,
"error": "",
"data": {
"job": job_res["data"]["job"],
"results": job_res["data"]["results"]
}
}
# if celery (full stack async mode)
# is working on this task,
# return the initial record data we have.
# from there the client will have to poll
# to get the final results
elif not get_result and job_res["status"] == NOTDONE:
res = {
"status": SUCCESS,
"code": drf_status.HTTP_201_CREATED,
"error": "",
"data": {
"job": req_data["ml_job_data"],
"results": req_data["ml_result_data"]
}
}
else:
res = {
"status": ERR,
"code": drf_status.HTTP_500_INTERNAL_SERVER_ERROR,
"error": job_res["err"],
"data": {
"job": None,
"results": None
}
}
# end of processing result
except Exception as e:
last_step = ("{} Failed with ex={}").format(self.class_name, e)
log.error(last_step)
res = {
"status": ERR,
"code": drf_status.HTTP_400_BAD_REQUEST,
"error": last_step,
"data": last_step
}
# end of try/ex
log.info(("{} create res={}").format(self.class_name, str(res)[0:30]))
return res