def fit_solution(raven_json_str=None): """ Send a FitSolutionRequest to the FitSolution command """ if raven_json_str is None: err_msg = 'No data found for the FitSolutionRequest' return err_resp(err_msg) # -------------------------------- # Make sure it's valid JSON # -------------------------------- raven_json_info = json_loads(raven_json_str) if not raven_json_info.success: return err_resp(raven_json_info.err_msg) # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse(raven_json_str, core_pb2.FitSolutionRequest()) except ParseError as err_obj: err_msg = ('Failed to convert JSON to gRPC: %s' ' (req_search_solutions)' '\nraven_json_str: %s') % \ (err_obj, raven_json_str) print('-' * 40) print(err_msg) return err_resp(err_msg) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: resp = core_pb2.FitSolutionResponse(\ request_id='requestId_%s' % get_alphanumeric_string(6)) return ok_resp(message_to_json(resp)) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.FitSolution(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: return err_resp(str(err_obj)) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- return ok_resp(message_to_json(reply))
def solution_export(raven_json_str=None): """ Send a SolutionExportRequest to the SolutionExport command """ if raven_json_str is None: err_msg = 'No data found for the SolutionExportRequest' return err_resp(err_msg) # -------------------------------- # Make sure it's valid JSON # -------------------------------- raven_json_info = json_loads(raven_json_str) if not raven_json_info.success: return err_resp(raven_json_info.err_msg) # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse(raven_json_str, core_pb2.SolutionExportRequest()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) return err_resp(err_msg) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: resp = core_pb2.SolutionExportResponse() return ok_resp(message_to_json(resp)) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.SolutionExport(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: return err_resp(str(err_obj)) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- return ok_resp(message_to_json(reply))
def list_primitives(): """ Send a ListPrimitivesRequest to the ListPrimitives command """ # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse("{}", core_pb2.ListPrimitivesRequest()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) return err_resp(err_msg) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: resp_str = get_grpc_test_json(\ 'test_responses/ListPrimitivesResponse_ok.json', dict()) return ok_resp(resp_str) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.ListPrimitives(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: return err_resp(str(err_obj)) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- return ok_resp(message_to_json(reply))
def stream_and_store_results(raven_json_str, stored_request_id, grpc_req_obj_name, grpc_call_name, **kwargs): """Make the grpc call which has a streaming response grpc_req_obj_name: "core_pb2.GetSearchSolutionsResultsRequest", etc grpc_call_name: "GetSearchSolutionsResults", etc """ core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: StoredRequestUtil.set_error_status(stored_request_id, err_msg) return # optional: used to stream messages back to client via channels # websocket_id = kwargs.get('websocket_id', None) # grpc_req_obj = eval(grpc_req_obj_name) grpc_rpc_call_function = eval('core_stub.%s' % grpc_call_name) # -------------------------------- # convert the JSON string to a gRPC request # Yes: done for the 2nd time # -------------------------------- try: req = Parse(raven_json_str, grpc_req_obj()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) StoredRequestUtil.set_error_status(stored_request_id, err_msg) return # -------------------------------- # Send the gRPC request # -------------------------------- msg_cnt = 0 try: # ----------------------------------------- # Iterate through the streaming responses # ----------------------------------------- for reply in grpc_rpc_call_function(\ req, timeout=settings.TA2_GRPC_LONG_TIMEOUT): msg_cnt += 1 stored_resp = None # to hold a StoredResponse object # ----------------------------------------- # parse the response # ----------------------------------------- msg_json_str = message_to_json(reply) msg_json_info = json_loads(msg_json_str) # ----------------------------------------- # does it look ok? # ----------------------------------------- if not msg_json_info.success: print('PROBLEM HERE TO LOG!') user_msg = 'failed to store response: %s' % \ msg_json_info.err_msg ws_msg = WebsocketMessage.get_fail_message(\ grpc_call_name, user_msg, msg_cnt=msg_cnt) ws_msg.send_message(websocket_id) continue # ----------------------------------------- # Looks good, save the response # ----------------------------------------- stored_resp_info = StoredResponse.add_response(\ stored_request_id, response=msg_json_info.result_obj) # ----------------------------------------- # Make sure the response was saved (probably won't happen) # ----------------------------------------- if not stored_resp_info.success: # Not good but probably won't happen # send a message to the user... # user_msg = 'failed to store response: %s' % \ msg_json_info.err_msg ws_msg = WebsocketMessage.get_fail_message(\ grpc_call_name, user_msg, msg_cnt=msg_cnt) ws_msg.send_message(websocket_id) # Wait for the next response... continue # ----------------------------------------------- # send responses back to any open WebSockets # --------------------------------------------- if websocket_id: stored_resp = stored_resp_info.result_obj ws_msg = WebsocketMessage.get_success_message(\ grpc_call_name, 'it worked', msg_cnt=msg_cnt, data=stored_resp.as_dict()) print('ws_msg: %s' % ws_msg) #print('ws_msg', ws_msg.as_dict()) ws_msg.send_message(websocket_id) StoredResponse.mark_as_read(stored_resp) # ----------------------------------------------- print('msg received #%d' % msg_cnt) except grpc.RpcError as err_obj: StoredRequestUtil.set_error_status(\ stored_request_id, str(err_obj)) return #except Exception as err_obj: # StoredRequestUtil.set_error_status(\ # stored_request_id, # str(err_obj)) # return StoredRequestUtil.set_finished_ok_status(stored_request_id)
def run_get_search_solution_results(self): """Run SearchSolutions against a TA2""" # ----------------------------------- # (1) make GRPC request object # ----------------------------------- params_dict = dict(searchId=self.search_id) params_info = json_dumps(params_dict) if not params_info.success: self.send_websocket_err_msg(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, params_info.err_msg) return try: grpc_req = Parse(params_info.result_obj, core_pb2.GetSearchSolutionsResultsRequest()) except ParseError as err_obj: err_msg = ('GetSearchSolutionsResultsRequest: Failed to' ' convert JSON to gRPC: %s') % (err_obj) self.send_websocket_err_msg(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, params_info.err_msg) return # -------------------------------- # (2) Save the request to the db # -------------------------------- stored_request = StoredRequest(\ user=self.user_object, search_id=self.search_id, workspace='(not specified)', request_type=ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, is_finished=False, request=params_dict) stored_request.save() # -------------------------------- # (2a) Behavioral logging # -------------------------------- log_data = dict(session_key=self.session_key, feature_id=ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, activity_l1=bl_static.L1_MODEL_SELECTION, activity_l2=bl_static.L2_MODEL_SEARCH, other=params_dict) LogEntryMaker.create_ta2ta3_entry(self.user_object, log_data) # -------------------------------- # (3) Make the gRPC request # -------------------------------- core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) msg_cnt = 0 try: # ----------------------------------------- # Iterate through the streaming responses # Note: The StoredResponse.id becomes the pipeline id # ----------------------------------------- for reply in core_stub.GetSearchSolutionsResults(\ grpc_req, timeout=settings.TA2_GRPC_LONG_TIMEOUT): msg_cnt += 1 # ----------------------------------------------- # Parse the response into JSON + store response # ----------------------------------------------- msg_json_str = message_to_json(reply) msg_json_info = json_loads(msg_json_str) if not msg_json_info.success: user_msg = 'Failed to convert response to JSON: %s' % \ msg_json_info.err_msg self.send_websocket_err_msg(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, user_msg) StoredResponse.add_stream_err_response(\ stored_response, user_msg) # Wait for next response.... continue result_json = msg_json_info.result_obj # TA2s (specifically NYU) responds once when trying a new pipeline, with a message missing a solutionId # the same process responds again once the solution contains a solutionId print('results json from TA2') print(result_json) if not result_json.get('solutionId'): continue if ta2_static.KEY_SOLUTION_ID not in result_json: user_msg = '"%s" not found in response to JSON: %s' % \ (ta2_static.KEY_SOLUTION_ID, result_json) StoredResponse.add_stream_err_response(\ stored_response, user_msg) self.send_websocket_err_msg(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, user_msg) # Wait for next response.... continue # Solution id used for DescribeSolution... # solution_id = result_json[ta2_static.KEY_SOLUTION_ID] # ----------------------------------------- # Looks good, save the response # ----------------------------------------- stored_resp_info = StoredResponse.add_stream_success_response(\ stored_request, result_json) # ----------------------------------------- # Tracking this in the behavioral log, # e.g. checking time lapse between creation # of solution and if user investigates this model, # later, if at all # ----------------------------------------- log_data = dict(session_key=self.session_key, feature_id=ta2_static. GET_SEARCH_SOLUTIONS_RESULTS_RESPONSE, activity_l1=bl_static.L1_MODEL_SELECTION, activity_l2=bl_static.L2_MODEL_SEARCH, other=result_json) LogEntryMaker.create_ta2ta3_entry(self.user_object, log_data) # ----------------------------------------- # Make sure the response was saved (probably won't happen) # ----------------------------------------- if not stored_resp_info.success: # Not good but probably won't happen # send a message to the user... # user_msg = 'Failed to store response from %s: %s' % \ (ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, msg_json_info.err_msg) StoredResponse.add_stream_err_response(\ stored_response, user_msg) self.send_websocket_err_msg(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, user_msg) # Wait for the next response... continue # --------------------------------------------- # Looks good! Get the StoredResponse # - This id will be used as the pipeline id # --------------------------------------------- stored_response = stored_resp_info.result_obj stored_response.use_id_as_pipeline_id() StoredResponse.add_stream_success_response(\ stored_response, stored_response) # ----------------------------------------------- # send responses back to WebSocket # --------------------------------------------- ws_msg = WebsocketMessage.get_success_message(\ ta2_static.GET_SEARCH_SOLUTIONS_RESULTS, 'it worked', msg_cnt=msg_cnt, data=stored_response.as_dict()) print('ws_msg: %s' % ws_msg) #print('ws_msg', ws_msg.as_dict()) ws_msg.send_message(self.websocket_id) stored_response.mark_as_sent_to_user() print('msg received #%d' % msg_cnt) # ----------------------------------------------- # continue the process describe/score/etc # ----------------------------------------------- # DescribeSolution - run sync # self.run_describe_solution(stored_response.pipeline_id, solution_id, msg_cnt) # FitSolution - run async # print('PRE run_fit_solution') self.run_fit_solution(stored_response.pipeline_id, solution_id) print('POST run_fit_solution') print('PRE run_score_solution') self.run_score_solution(stored_response.pipeline_id, solution_id) print('POST run_score_solution') # ----------------------------------------------- # All results arrived, send message to UI # ----------------------------------------------- ws_msg = WebsocketMessage.get_success_message( \ ta2_static.ENDGetSearchSolutionsResults, {'searchId': self.search_id, 'message': 'it worked'}) print('ws_msg: %s' % ws_msg) ws_msg.send_message(self.websocket_id) except grpc.RpcError as err_obj: stored_request.set_error_status(str(err_obj)) return except Exception as err_obj: stored_request.set_error_status(str(err_obj)) return StoredRequestUtil.set_finished_ok_status(stored_request.id)
def run_get_score_solution_responses(self, request_id): """(2) Run GetScoreSolutionResults""" if self.has_error(): return if not request_id: self.send_websocket_err_msg(ta2_static.GET_SCORE_SOLUTION_RESULTS, 'request_id must be set') return # ----------------------------------- # (1) make GRPC request object # ----------------------------------- params_dict = {ta2_static.KEY_REQUEST_ID: request_id} params_info = json_dumps(params_dict) try: grpc_req = Parse(params_info.result_obj, core_pb2.GetScoreSolutionResultsRequest()) except ParseError as err_obj: err_msg = ('Failed to convert JSON to gRPC: %s') % (err_obj) self.send_websocket_err_msg(ta2_static.GET_SCORE_SOLUTION_RESULTS, err_msg) return # -------------------------------- # (2) Save the request to the db # -------------------------------- stored_request = StoredRequest(\ user=self.user_object, request_type=ta2_static.GET_SCORE_SOLUTION_RESULTS, search_id=self.search_id, pipeline_id=self.pipeline_id, is_finished=False, request=params_dict) stored_request.save() # -------------------------------- # (2a) Behavioral logging # -------------------------------- log_data = dict(session_key=self.session_key, feature_id=ta2_static.GET_SCORE_SOLUTION_RESULTS, activity_l1=bl_static.L1_MODEL_SELECTION, activity_l2=bl_static.L2_MODEL_SUMMARIZATION, other=params_dict) LogEntryMaker.create_ta2ta3_entry(self.user_object, log_data) # -------------------------------- # (3) Make the gRPC request # -------------------------------- core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) msg_cnt = 0 try: # ----------------------------------------- # Iterate through the streaming responses # Note: The StoredResponse.id becomes the pipeline id # ----------------------------------------- for reply in core_stub.GetScoreSolutionResults(\ grpc_req, timeout=settings.TA2_GRPC_LONG_TIMEOUT): msg_cnt += 1 stored_response = None # to hold a StoredResponse object # ----------------------------------------------- # Parse the response into JSON + store response # ----------------------------------------------- msg_json_str = message_to_json(reply) msg_json_info = json_loads(msg_json_str) if not msg_json_info.success: err_msg = ('Failed to convert JSON to gRPC: %s') % \ (err_obj,) StoredResponse.add_stream_err_response( stored_request, user_msg) self.send_websocket_err_msg(\ ta2_static.GET_SCORE_SOLUTION_RESULTS, err_msg) # Wait for next response.... continue result_json = msg_json_info.result_obj # ----------------------------------------- # Looks good, save the response # ----------------------------------------- stored_resp_info = StoredResponse.add_stream_success_response(\ stored_request, result_json) # ----------------------------------------- # Make sure the response was saved (probably won't happen) # ----------------------------------------- if not stored_resp_info.success: # Not good but probably won't happen # send a message to the user... # self.send_websocket_err_msg(\ ta2_static.GET_SCORE_SOLUTION_RESULTS, stored_resp_info.err_msg) # StoredResponse.add_stream_err_response(\ stored_request, stored_resp_info.err_msg) # continue # --------------------------------------------- # Looks good! Get the StoredResponse # - send responses back to WebSocket # --------------------------------------------- stored_response = stored_resp_info.result_obj stored_response.set_pipeline_id(self.pipeline_id) # --------------------------------------------- # If progress is complete, # send response back to WebSocket # --------------------------------------------- progress_val = get_dict_value(\ result_json, [ta2_static.KEY_PROGRESS, ta2_static.KEY_PROGRESS_STATE]) if (not progress_val.success) or \ (progress_val.result_obj != ta2_static.KEY_PROGRESS_COMPLETED): user_msg = 'GetScoreSolutionResultsResponse is not yet complete' LOGGER.info(user_msg) # wait for next message... continue ws_msg = WebsocketMessage.get_success_message(\ ta2_static.GET_SCORE_SOLUTION_RESULTS, 'it worked', msg_cnt=msg_cnt, data=stored_response.as_dict()) LOGGER.info('ws_msg: %s' % ws_msg) #print('ws_msg', ws_msg.as_dict()) ws_msg.send_message(self.websocket_id) # stored_response.mark_as_sent_to_user() except grpc.RpcError as err_obj: stored_request.set_error_status(str(err_obj)) return except Exception as err_obj: stored_request.set_error_status(str(err_obj)) return StoredRequestUtil.set_finished_ok_status(stored_request.id)
def solution_export3(user, raven_json, **kwargs): """ Send a SolutionExportRequest to the SolutionExport command """ if not isinstance(user, User): err_msg = '"user" must be a User object' return err_resp(err_msg) if not isinstance(raven_json, dict): err_msg = 'raven_dict must be a python dict' return err_resp(err_msg) if not ta2_static.KEY_SEARCH_ID in raven_json: err_msg = (f'Key: "{ta2_static.KEY_SEARCH_ID}" not found in the' f' "raven_json" dict. (solution_export3)') return err_resp(err_msg) search_id = raven_json.pop( ta2_static.KEY_SEARCH_ID) # not needed for GRPC call session_key = kwargs.get(SESSION_KEY, '') # -------------------------------- # Convert dict to string # -------------------------------- raven_json_info = json_dumps(raven_json) if not raven_json_info.success: return err_resp(raven_json_info.err_msg) raven_json_str = raven_json_info.result_obj # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse(raven_json_str, core_pb2.SolutionExportRequest()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) return err_resp(err_msg) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: resp = core_pb2.SolutionExportResponse() return ok_resp(message_to_json(resp)) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Save the request to the db # -------------------------------- stored_request = StoredRequest(\ user=user, search_id=search_id, workspace='(not specified)', request_type=ta2_static.SOLUTION_EXPORT, is_finished=False, request=raven_json) stored_request.save() # -------------------------------- # Behavioral logging # -------------------------------- log_data = dict(session_key=session_key, feature_id=ta2_static.SOLUTION_EXPORT, activity_l1=bl_static.L1_MODEL_SELECTION, activity_l2=bl_static.L2_MODEL_EXPORT, other=raven_json) LogEntryMaker.create_ta2ta3_entry(user, log_data) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.SolutionExport(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: user_msg = f'Error: {err_obj}' StoredResponse.add_err_response(stored_request, user_msg) return err_resp(user_msg) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- resp_json_str = message_to_json(reply) resp_json_dict_info = json_loads(resp_json_str) if not resp_json_dict_info.success: user_msg = (f'Failed to convert GRPC response to JSON:' f' {resp_json_dict_info.err_msg}') StoredResponse.add_err_response(stored_request, user_msg) return err_resp(user_msg) StoredResponse.add_success_response(stored_request, resp_json_dict_info.result_obj) return ok_resp(resp_json_str)
def search_solutions(raven_json_str=None): """ Send a SearchSolutionsRequest to the SearchSolutions command """ print('raven_json_str', raven_json_str) if raven_json_str is None: err_msg = 'No data found for the SearchSolutionsRequest' return err_resp(err_msg) # This is a dict or OrderedDict, make it a json string # if isinstance(raven_json_str, dict): json_str_info = json_dumps(raven_json_str) if not json_str_info.success: return json_str_info raven_json_str = json_str_info.result_obj else: # Make sure the string is valid JSON # raven_json_info = json_loads(raven_json_str) if not raven_json_info.success: return err_resp(raven_json_info.err_msg) print('SearchSolutionsRequest (string)', raven_json_str) # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse(raven_json_str, core_pb2.SearchSolutionsRequest()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) return err_resp(err_msg) print('req', req) print('-' * 40) print('raven_json_str', raven_json_str) print('-' * 40) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: search_id = 'search_id_%s' % get_alphanumeric_string(6) resp = core_pb2.SearchSolutionsResponse(search_id=search_id) # print('message_to_json(req)', message_to_json(resp)) return ok_resp(message_to_json(resp)) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.SearchSolutions(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: return err_resp(str(err_obj)) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- return ok_resp(message_to_json(reply))
def end_search_solutions(raven_json_str=None, **kwargs): """ Send a EndSearchSolutionsRequest to the EndSearchSolutions command optional kwargs: user = User object for logging """ if raven_json_str is None: err_msg = 'No data found for the EndSearchSolutionsRequest' return err_resp(err_msg) # -------------------------------- # Make sure it's valid JSON # -------------------------------- raven_json_info = json_loads(raven_json_str) if not raven_json_info.success: return err_resp(raven_json_info.err_msg) if not ta2_static.KEY_SEARCH_ID in raven_json_info.result_obj: err_msg = (f'The send solutions request did not include' f' a "{ta2_static.KEY_SEARCH_ID}" key') return err_resp(err_msg) search_id = raven_json_info.result_obj[ta2_static.KEY_SEARCH_ID] # -------------------------------- # optional logging # -------------------------------- user = kwargs.get('user') stored_request = None # Begin to log D3M call # if user: stored_request = StoredRequest(\ user=user, request_type=ta2_static.END_SEARCH_SOLUTIONS, search_id=search_id, is_finished=False, request=raven_json_info.result_obj) stored_request.save() # -------------------------------- # convert the JSON string to a gRPC request # -------------------------------- try: req = Parse(raven_json_str, core_pb2.EndSearchSolutionsRequest()) except ParseError as err_obj: err_msg = 'Failed to convert JSON to gRPC: %s' % (err_obj) return err_resp(err_msg) # In test mode, return canned response # if settings.TA2_STATIC_TEST_MODE: resp = core_pb2.EndSearchSolutionsResponse() # print('message_to_json(req)', message_to_json(resp)) return ok_resp(message_to_json(resp)) core_stub, err_msg = TA2Connection.get_grpc_stub() if err_msg: return err_resp(err_msg) # -------------------------------- # Send the gRPC request # -------------------------------- try: reply = core_stub.EndSearchSolutions(\ req, timeout=settings.TA2_GRPC_SHORT_TIMEOUT) except Exception as err_obj: return err_resp(str(err_obj)) # -------------------------------- # Convert the reply to JSON and send it back # -------------------------------- # This returns a JSON string reply_json_str = message_to_json(reply) # Double-check, make sure it converts back to a python dict # json_format_info = json_loads(reply_json_str) if not json_format_info.success: if user: StoredResponse.add_err_response(stored_request, json_format_info.err_msg) return err_resp(json_format_info.err_msg) # Looks good, save response and return value # if user: StoredResponse.add_success_response(stored_request, json_format_info.result_obj) return ok_resp(json_format_info.result_obj)