def new_reply_with_array_obj_input(body): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header if connexion.request.is_json: body_json = connexion.request.get_json() body = Comment.from_dict(body_json) # noqa: E501 try: c = operation() comment_id = body_json['comment_id'] user_memo = body_json['user_memo'] _ = c.new_reply_byid(comment_id=comment_id, user_memo=user_memo) return Message(msg="ok").to_dict(), 200, header except Exception as e: return Message( request_status="error", msg="UNKNOWERROR: {}".format(e)).to_dict(), 200, header else: error_msg = Message(request_status="error", msg="connexion.request.is_json") return error_msg.to_dict(), 500, header
def update_reply_with_array_obj_input(body): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header error_msg = Message(request_status="error", msg="NotImplementedError") return error_msg.to_dict(), 500, header
def message_get(): """ message_get Returns a greeting. :rtype: Message """ response = Message() response.message = 'Hello World' return response
def delete_reply_with_array_obj_input(reply_id): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header try: c = operation() c.delete_reply_byid(reply_id=reply_id) return Message(msg="ok").to_dict(), 200, header except Exception as e: return Message(request_status="error", msg="UNKNOWERROR: {}".format(e)).to_dict(), 200, header
def __init__(self, question_number): """ Initialize the class :param question_number: which question number this is """ self._question_number = question_number self._now = datetime.datetime.now() self._results = [] self._num_results = 0 # Create the message object and fill it with attributes about the response self.message = Message() self.message.type = "translator_reasoner_message" self.message.tool_version = RTXConfiguration.version self.message.schema_version = "0.9.2" self.message.message_code = "OK" #self.message.code_description = "Placeholder for description" self.message.code_description = "%s results found" % self._num_results #### Create an empty master knowledge graph self.message.knowledge_graph = KnowledgeGraph() self.message.knowledge_graph.nodes = [] self.message.knowledge_graph.edges = [] #### Create an internal lookup dict of nodes and edges for maintaining the master knowledge graph self._node_ids = dict() self._edge_ids = dict() self._edge_counter = 0
def integrate(self, query): if "options" in query and query["options"] is not None: if re.search("integrate=.+", query["options"]): integrate_option = query["options"] eprint(integrate_option) target_string = re.sub("integrate=", "", integrate_option) targets = re.split(",", target_string) eprint(targets) final_message = Message() for reasoner_id in targets: eprint("Looping with reasoner_id=" + reasoner_id) query["options"] = "foo" url = None if reasoner_id == "RTX": url = "https://arax.rtx.ai/devED/api/rtx/v1/query" elif reasoner_id == "Robokop": url = "http://robokop.renci.org:6011/api/query" elif reasoner_id == "Indigo": url = "https://indigo.ncats.io/reasoner/api/v0/query" url = None else: eprint("ERROR: Unrecognized target '" + target + "'") if url is not None: eprint("Querying url " + url) message_content = requests.post( url, headers={'accept': 'application/json'}, json=query) status_code = message_content.status_code message_dict = message_content.json() message = Message.from_dict(message_dict) if reasoner_id == "RTX": final_message = message if reasoner_id == "Robokop" or reasoner_id == "Indigo": #if reasoner_id == "Robokop": eprint("Merging in " + reasoner_id) message = self.fix_message(query, message, reasoner_id) if message.results is not None: final_message = self.merge_message2( final_message, message) return (final_message) return (None) return (None)
def new_class_with_array_obj_input(body): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header """Info of class # noqa: E501 :param body: Pet object that needs to be added to the store :type body: dict | bytes :rtype: object """ if connexion.request.is_json: body_json = connexion.request.get_json() body = Comment.from_dict(body_json) # noqa: E501 try: c = comment_operation() major = body_json[ 'major'] if 'major' in body_json else "這傢伙很懶,什麼都沒有寫" midexam = body_json[ 'midexam'] if 'midexam' in body_json else "這傢伙很懶,什麼都沒有寫" endexam = body_json[ 'endexam'] if 'endexam' in body_json else "這傢伙很懶,什麼都沒有寫" value = body_json[ 'value'] if 'value' in body_json else "這傢伙很懶,什麼都沒有寫" cost = body_json['cost'] if 'cost' in body_json else "這傢伙很懶,什麼都沒有寫" classcall = body_json[ 'classcall'] if 'classcall' in body_json else 2 homework = body_json['homework'] if 'homework' in body_json else 2 classexam = body_json[ 'classexam'] if 'classexam' in body_json else 2 _ = c.new_comment_byid(body.class_name, body.teacher_name, major, midexam, endexam, body.user_memo, value, cost, classcall, homework, classexam) return Message(msg="ok").to_dict(), 200, header except Exception as e: return Message( request_status="error", msg="UNKNOWERROR: {}".format(e)).to_dict(), 200, header else: error_msg = Message(request_status="error", msg="connexion.request.is_json") return error_msg.to_dict(), 500, header
def main(): #### Create a response object response = Response() #### Create an ActionsParser object from actions_parser import ActionsParser actions_parser = ActionsParser() #### Set a simple list of actions actions_list = [ "filter(start_node=1, maximum_results=10, minimum_confidence=0.5)", "return(message=true,store=false)" ] #### Parse the action_list and print the result result = actions_parser.parse(actions_list) response.merge(result) if result.status != 'OK': print(response.show(level=Response.DEBUG)) return response actions = result.data['actions'] #### Read message #2 from the database. This should be the acetaminophen proteins query result message sys.path.append(os.path.dirname(os.path.abspath(__file__))+"/../../UI/Feedback") from RTXFeedback import RTXFeedback araxdb = RTXFeedback() message_dict = araxdb.getMessage(2) #### The stored message comes back as a dict. Transform it to objects sys.path.append(os.path.dirname(os.path.abspath(__file__))+"/../OpenAPI/python-flask-server/") from swagger_server.models.message import Message message = Message().from_dict(message_dict) #### Create a filter object and use it to apply action[0] from the list filter = ARAXFilter() result = filter.apply(message,actions[0]['parameters']) response.merge(result) if result.status != 'OK': print(response.show(level=Response.DEBUG)) return response response.data = result.data #### Show the final message print(response.show(level=Response.DEBUG)) response.data['message_stats'] = { 'n_results': message.n_results, 'id': message.id, 'reasoner_id': message.reasoner_id, 'tool_version': message.tool_version } print(json.dumps(ast.literal_eval(repr(response.data['parameters'])),sort_keys=True,indent=2)) for result in message.results: if result.essence is not None: essence = result.essence else: essence = f"{len(result.node_bindings)} node bindings, {len(result.edge_bindings)} edge bindings" print(f" - {essence}") print(json.dumps(ast.literal_eval(repr(response.data['message_stats'])),sort_keys=True,indent=2))
def from_dict(self, message): if str(message.__class__ ) != "<class 'swagger_server.models.message.Message'>": message = Message().from_dict(message) message.query_graph = QueryGraph().from_dict(message.query_graph) message.knowledge_graph = KnowledgeGraph().from_dict( message.knowledge_graph) #### This is an unfortunate hack that fixes qnode.curie entries #### Officially a curie can be a str or a list. But Swagger 2.0 only permits one type and we set it to str #### so when it gets converted from_dict, the list gets converted to a str because that's its type #### Here we force it back. This should no longer be needed when we are properly on OpenAPI 3.0 if message.query_graph is not None and message.query_graph.nodes is not None: for qnode in message.query_graph.nodes: if qnode.curie is not None and isinstance(qnode.curie, str): if qnode.curie[0:2] == "['": try: qnode.curie = ast.literal_eval(qnode.curie) except: pass #new_nodes = [] #for qnode in message.query_graph.nodes: # print(type(qnode)) # new_nodes.append(QNode().from_dict(qnode)) #message.query_graph.nodes = new_nodes #for qedge in message.query_graph.edges: # new_edges.append(QEdge().from_dict(qedge)) #message.query_graph.edges = new_edges if message.results is not None: for result in message.results: if result.result_graph is not None: #eprint(str(result.result_graph.__class__)) if str( result.result_graph.__class__ ) != "<class 'swagger_server.models.knowledge_graph.KnowledgeGraph'>": result.result_graph = KnowledgeGraph().from_dict( result.result_graph) return message
def update_class_with_array_obj_input(body): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header """Info of class # noqa: E501 :param body: Pet object that needs to be added to the store :type body: dict | bytes :rtype: object """ if connexion.request.is_json: body = Comment.from_dict(connexion.request.get_json()) # noqa: E501 return body, 200, header else: error_msg = Message(request_status="error", msg="connexion.request.is_json") return error_msg.to_dict(), 500, header
def test_add_message(self): """Test case for add_message Add a new message (to the agent's multichain stream) """ body = Message() response = self.client.open( '/v0_9_1/{agentIdPath}/Messages'.format(agentIdPath='agentIdPath_example'), method='POST', data=json.dumps(body), content_type='application/json') self.assert200(response, 'Response body is : ' + response.data.decode('utf-8'))
def test_message(self): """Test case for message requesting chatbot to handle task """ message = Message() response = self.client.open( '/v1/bot', method='POST', data=json.dumps(message), content_type='application/json') self.assert200(response, 'Response body is : ' + response.data.decode('utf-8'))
def get_message_by_id(messageId): # noqa: E501 """Find message by ID Returns a single message # noqa: E501 :param messageId: ID of message to return :type messageId: str :rtype: Message """ response = Message("A comprehensive journey into the PRESENT of DevOps") return response
def delete_class_with_array_obj_input(comment_id): # noqa: E501 # 拒絕非認證的來源 refuse user or origin Origin = connexion.request.headers["Sec-Fetch-Site"] if "Sec-Fetch-Site" in connexion.request.headers else \ connexion.request.headers["Origin"] if "Origin" in connexion.request.headers else None if Origin != "same-site" and Origin != "same-origin" and Origin != "https://goodclass.cf": return {"ERROR": "Unauthorized USER"}, 401, header """Info of class # noqa: E501 :param comment_id: Eamples: 1 :type comment_id: int :rtype: object """ try: c = comment_operation() c.delete_comment_byid(comment_id=comment_id) return Message(msg="ok").to_dict(), 200, header except Exception as e: return Message(request_status="error", msg="UNKNOWERROR: {}".format(e)).to_dict(), 200, header
def add_message(agentIdPath, body): # noqa: E501 """Add a new message (to the agent's multichain stream) Adds a new Message # noqa: E501 :param agentIdPath: ID of marketplace agent :type agentIdPath: str :param body: Message that should to be added to the blockchain :type body: dict | bytes :rtype: Message """ if connexion.request.is_json: json_body = connexion.request.get_json() body = Message.from_dict(json_body) # noqa: E501 body.indexkeys.append('id:'+body.id) json_body['indexkeys'].append('id:'+json_body['id']) multichain_client.publish(agentIdPath,body.indexkeys, json_body) return Response(status=201, mimetype='application/json') else: return Response(status=405, mimetype='application/json')
def message(message=None): # noqa: E501 """requesting chatbot to handle task ask bot # noqa: E501 :param message: :type message: dict | bytes :rtype: InlineResponse200 """ if connexion.request.is_json: message = Message.from_dict(connexion.request.get_json()) # noqa: E501 msg = message._message bot = RiveScript() path = os.path.dirname(os.path.realpath(__file__))+'/brain' bot.load_directory(path) bot.sort_replies() reply = bot.reply("localuser", msg) if reply == '[ERR: No Reply Matched]': reply = "The bot can not understand you question:(" return reply , 200, None
def createMessage(self): #### Create the message object and fill it with attributes about the message message = Message() message.message_code = "OK" message.code_description = "??" return message
from swagger_server.models.message import Message a = Message(request_status="success",msg="hi") print(a.to_dict())
def processExternalPreviousMessageProcessingPlan(self, inputEnvelope): debug = 1 if debug: eprint( "DEBUG: Entering processExternalPreviousMessageProcessingPlan") messages = [] finalMessage = None finalMessage_id = None query = None #### Pull out the main processing plan envelope envelope = PreviousMessageProcessingPlan.from_dict( inputEnvelope["previous_message_processing_plan"]) #### If there are URIs provided, try to load them if envelope.previous_message_uris is not None: if debug: eprint("DEBUG: Got previous_message_uris") for uri in envelope.previous_message_uris: if debug: eprint("DEBUG: messageURI=" + uri) matchResult = re.match( r'http[s]://arax.ncats.io/.*api/rtx/.+/message/(\d+)', uri, re.M | re.I) if matchResult: message_id = matchResult.group(1) if debug: eprint( "DEBUG: Found local ARAX identifier corresponding to message_id " + message_id) if debug: eprint("DEBUG: Loading message_id " + message_id) message = self.getMessage(message_id) #eprint(type(message)) if not isinstance(message, tuple): if debug: eprint("DEBUG: Original question was: " + message["original_question"]) messages.append(message) finalMessage_id = message_id query = { "query_type_id": message["query_type_id"], "restated_question": message["restated_question"], "terms": message["terms"] } else: eprint("ERROR: Unable to load message_id " + message_id) return ({ "status": 404, "title": "Message not found", "detail": "There is no local message corresponding to message_id=" + str(message_id), "type": "about:blank" }, 404) #### If there are one or more previous_messages embedded in the POST, process them if envelope.previous_messages is not None: if debug: eprint("DEBUG: Got previous_messages") for uploadedMessage in envelope.previous_messages: if debug: eprint("DEBUG: uploadedMessage is a " + str(uploadedMessage.__class__)) if str(uploadedMessage.__class__ ) == "<class 'swagger_server.models.message.Message'>": if uploadedMessage.results: message = ast.literal_eval(repr(uploadedMessage)) messages.append(message) if message["terms"] is None: message["terms"] = {"dummyTerm": "giraffe"} if message["query_type_id"] is None: message["query_type_id"] = "UnknownQ" if message["restated_question"] is None: message["restated_question"] = "What is life?" if message["original_question"] is None: message["original_question"] = "what is life" query = { "query_type_id": message["query_type_id"], "restated_question": message["restated_question"], "original_question": message["original_question"], "terms": message["terms"] } else: eprint( "Uploaded message does not contain a results. May be the wrong format" ) return ({ "status": 404, "title": "Bad uploaded Message", "detail": "There is no results in the uploaded Message object=", "type": "about:blank" }, 404) else: eprint( "Uploaded message is not of type Message. It is of type" + str(uploadedMessage.__class__)) return ({ "status": 404, "title": "Bad uploaded Message", "detail": "Uploaded message is not of type Message. It is of type" + str(uploadedMessage.__class__), "type": "about:blank" }, 404) #### Take different actions based on the number of messages we now have in hand n_messages = len(messages) if n_messages == 0: return ({ "status": 499, "title": "No Messages", "detail": "Did not get any useful Message objects", "type": "about:blank" }, 499) elif n_messages == 1: finalMessage = messages[0] else: finalMessage = TxMessage.from_dict(messages[0]) counter = 1 while counter < n_messages: messageToMerge = TxMessage.from_dict(messages[counter]) if messageToMerge.reasoner_id is None: messageToMerge.reasoner_id = "Unknown" if messageToMerge.reasoner_id != "ARAX": messageToMerge = self.fix_message( query, messageToMerge, messageToMerge.reasoner_id) finalMessage = self.merge_message(finalMessage, messageToMerge) counter += 1 finalMessage = ast.literal_eval(repr(finalMessage)) #return( { "status": 498, "title": "Multiple Messages", "detail": "I have multiple messages. Merging code awaits!", "type": "about:blank" }, 498) #### Examine the options that were provided and act accordingly optionsDict = {} if envelope.options: if debug: eprint("DEBUG: Got options") for option in envelope.options: if debug: eprint("DEBUG: option=" + option) optionsDict[option] = 1 #### If there are processing_actions, then fulfill those processing_actions = [] if envelope.processing_actions: if debug: eprint("DEBUG: Found processing_actions") actions_parser = ActionsParser() result = actions_parser.parse(envelope.processing_actions) if result.error_code != 'OK': eprint(result) raise () #### Message suffers from a dual life as a dict and an object. above we seem to treat it as a dict. Fix that. FIXME #### Below we start treating it as and object. This should be the way forward. #### This is not a good place to do this, but may need to convert here from ARAX_messenger import ARAXMessenger finalMessage = ARAXMessenger().from_dict(finalMessage) #### Process each action in order action_stats = {} actions = result.data['actions'] for action in actions: if debug: eprint( f"DEBUG: Considering action '{action['command']}' with parameters {action['parameters']}" ) #### If we encounter a return, then this is the end of the line if action['command'] == 'return': action_stats['return_action'] = action break if action['command'] == 'filter': filter = ARAXFilter() result = filter.apply(finalMessage, action['parameters']) if result.error_code != 'OK': response = result break else: if debug: eprint( f"DEBUG: Action '{action['command']}' is not known" ) #### At the end, process the explicit return() action, or implicitly perform one return_action = { 'command': 'return', 'parameters': { 'message': 'false', 'store': 'false' } } if action is not None and action['command'] == 'return': return_action = action #### If an explicit one left out some parameters, set the defaults if 'store' not in return_action['parameters']: return_action['parameters']['store'] == 'false' if 'message' not in return_action['parameters']: return_action['parameters']['message'] == 'false' #if "AnnotateDrugs" in optionsDict: # if debug: eprint("DEBUG: Annotating drugs") # annotate_std_results(finalMessage) if return_action['parameters']['store'] == 'true': if debug: eprint("DEBUG: Storing resulting Message") finalMessage_id = self.addNewMessage( TxMessage.from_dict(finalMessage), query) #### If requesting a full redirect to the resulting message display. This doesn't really work I don't think #if "RedirectToMessage" in optionsDict: # #redirect("https://arax.ncats.io/api/rtx/v1/message/"+str(finalMessage_id), code=302) # #return( { "status": 302, "redirect": "https://arax.ncats.io/api/rtx/v1/message/"+str(finalMessage_id) }, 302) # return( "Location: https://arax.ncats.io/api/rtx/v1/message/"+str(finalMessage_id), 302) #### If asking for the full message back if return_action['parameters']['message'] == 'true': return (finalMessage) #### Else just the id is returned else: #return( { "status": 200, "message_id": str(finalMessage_id), "n_results": finalMessage['n_results'], "url": "https://arax.ncats.io/api/rtx/v1/message/"+str(finalMessage_id) }, 200) return ({ "status": 200, "message_id": str(finalMessage_id), "n_results": finalMessage.n_results, "url": "https://arax.ncats.io/api/rtx/v1/message/" + str(finalMessage_id) }, 200)
def create_message(self, describe=False): """ Creates a basic empty Message object with basic boilerplate metadata :return: Response object with execution information and the new message object inside the data envelope :rtype: Response """ # Internal documentation setup #allowable_parameters = { 'action': { 'None' } } allowable_parameters = { 'dsl_command': '`create_message()`' } # can't get this name at run-time, need to manually put it in per https://www.python.org/dev/peps/pep-3130/ if describe: allowable_parameters[ 'brief_description'] = """The `create_message` method creates a basic empty Message object with basic boilerplate metadata such as reasoner_id, schema_version, etc. filled in. This DSL command takes no arguments""" return allowable_parameters #### Define a default response response = Response() self.response = response #### Create the top-level message response.info("Creating an empty template ARAX Message") message = Message() self.message = message #### Fill it with default information message.id = None message.type = "translator_reasoner_message" message.reasoner_id = "ARAX" message.tool_version = RTXConfiguration().version message.schema_version = "0.9.3" message.message_code = "OK" message.code_description = "Created empty template Message" message.context = "https://raw.githubusercontent.com/biolink/biolink-model/master/context.jsonld" #### Why is this _datetime ?? FIXME message._datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S") #### Create an empty master knowledge graph message.knowledge_graph = KnowledgeGraph() message.knowledge_graph.nodes = [] message.knowledge_graph.edges = [] #### Create an empty query graph message.query_graph = QueryGraph() message.query_graph.nodes = [] message.query_graph.edges = [] #### Create empty results message.results = [] message.n_results = 0 #### Return the response response.data['message'] = message return response
def query(self, query): #### Get our configuration information #### Create a Message object as a response response = Message() execution_string = None #### Determine a plan for what to do based on the input result = self.examine_incoming_query(query) if result["message_code"] != "OK": response.message_code = result["message_code"] response.code_description = result["code_description"] return response #### If we have a previous message processing plan, handle that if "have_previous_message_processing_plan" in result: rtxFeedback = RTXFeedback( ) # FIXME. This should be a separate class I think, not the Feedback class. TODO: Separate them rtxFeedback.connect() message = rtxFeedback.processExternalPreviousMessageProcessingPlan( query) rtxFeedback.disconnect() return (message) #### If we have a query_graph, pass this on to the QueryGraphReasoner if "have_query_graph" in result: qgr = QueryGraphReasoner() message = qgr.answer(query["message"]["query_graph"], TxltrApiFormat=True) #self.log_query(query,message,'new') rtxFeedback = RTXFeedback() rtxFeedback.connect() rtxFeedback.addNewMessage(message, query) rtxFeedback.disconnect() self.limit_message(message, query) return (message) #### Otherwise extract the id and the terms from the incoming parameters else: id = query["message"]["query_type_id"] terms = query["message"]["terms"] #### Check to see if the query_options indicates to query named resource and integrate the results if "have_query_type_id_and_terms" in result and "message" in query and "query_options" in query[ "message"] and "integrate" in query["message"]["query_options"]: response = self.integrate(query) #self.log_query(query,response,'remote') return response #### Create an RTX Feedback management object #eprint(query) rtxFeedback = RTXFeedback() rtxFeedback.connect() cachedMessage = rtxFeedback.getCachedMessage(query) #### If we can find a cached message for this query and this version of RTX, then return the cached message if (cachedMessage is not None): apiMessage = Message().from_dict(cachedMessage) rtxFeedback.disconnect() self.limit_message(apiMessage, query) if apiMessage.message_code is None: if apiMessage.result_code is not None: apiMessage.message_code = apiMessage.result_code else: apiMessage.message_code = "wha??" self.log_query(query, apiMessage, 'cached') return apiMessage #### Still have special handling for Q0 if id == 'Q0': q0 = Q0() message = q0.answer(terms["term"], use_json=True) if 'original_question' in query["message"]: message.original_question = query["message"][ "original_question"] message.restated_question = query["message"][ "restated_question"] message.query_type_id = query["message"]["query_type_id"] message.terms = query["message"]["terms"] id = message.id codeString = message.message_code self.log_query(query, message, 'new') rtxFeedback.addNewMessage(message, query) rtxFeedback.disconnect() self.limit_message(message, query) return (message) #### Else call out to original solution scripts for an answer else: #### If some previous processing has determined what the solution script to use is, then use that if execution_string is not None: command = "python3 " + execution_string #### Else use the ParseQuestion system to determine what the execution_string should be else: txltr = ParseQuestion() command = "python3 " + txltr.get_execution_string(id, terms) #### Set CWD to the QuestioningAnswering area and then invoke from the shell the Q1Solution code cwd = os.getcwd() os.chdir( os.path.dirname(os.path.abspath(__file__)) + "/../../../reasoningtool/QuestionAnswering") eprint(command) returnedText = subprocess.run([command], stdout=subprocess.PIPE, shell=True) os.chdir(cwd) #### reformat the stdout result of the shell command into a string reformattedText = returnedText.stdout.decode('utf-8') #eprint(reformattedText) #### Try to decode that string into a message object try: #data = ast.literal_eval(reformattedText) data = json.loads(reformattedText) message = Message.from_dict(data) if message.message_code is None: if message.result_code is not None: message.message_code = message.result_code else: message.message_code = "wha??" #### If it fails, the just create a new Message object with a notice about the failure except: message = Message() message.message_code = "InternalError" message.code_description = "Error parsing the message from the reasoner. This is an internal bug that needs to be fixed. Unable to respond to this question at this time. The unparsable message was: " + reformattedText #print(query) if 'original_question' in query["message"]: message.original_question = query["message"][ "original_question"] message.restated_question = query["message"][ "restated_question"] message.query_type_id = query["message"]["query_type_id"] message.terms = query["message"]["terms"] #### Log the result and return the Message object self.log_query(query, message, 'new') rtxFeedback.addNewMessage(message, query) rtxFeedback.disconnect() #### Limit message self.limit_message(message, query) return (message) #### If the query type id is not triggered above, then return an error message = Message() message.message_code = "UnsupportedQueryTypeID" message.code_description = "The specified query id '" + id + "' is not supported at this time" rtxFeedback.disconnect() return (message)