def index(request, p):
return Response("{} index page".format(request.request_uri))
def do_POST(self):
print(self.path.split('/?')[0])
is_matched = self.path.split('/?')[0]
if is_matched == '/activate':
from urllib.parse import urlparse
query = urlparse(self.path).query
query_components = dict(qc.split("=") for qc in query.split("&"))
# print(query_components, "query_components----->", query)
if query_components['token']:
self.path = '/activate'
elif is_matched == '/reset':
from urllib.parse import urlparse
query = urlparse(self.path).query
query_components = dict(qc.split("=") for qc in query.split("&"))
# print(query_components, "query_components----->", query)
if query_components['token']:
self.path = '/reset'
if self.path == '/register':
response = User().register(that=self)
if response['success']:
user_data = response['data'][0]
response = UserService().register(user_data=user_data,
that=self)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/activate':
response = UserService().activate(token=query_components['token'])
return Response(self).jsonResponse(status=200, data=response)
if self.path == '/login':
response = User().login(that=self)
if response['success']:
user_data = response['data'][0]
response = UserService().login(user_data=user_data)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/forgot':
response = User().forgot(that=self)
if response['success']:
user_data = response['data'][0]
response = UserService().forgot(user_data=user_data, that=self)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/reset':
response = User().reset(that=self)
if response['success']:
user_data = response['data'][0]
response = UserService().reset(token=query_components['token'],
user_data=user_data)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/create_note':
response = Note().create_note(that=self)
if response['success']:
user_data = response['data'][0]
response = NoteService().create_note(user_data=user_data)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/upload_profile_pic':
response = NoteService().upload_photo(that=self)
Response(self).jsonResponse(status=200, data=response)
if self.path == '/collaborator':
response = Note().collaborator(that=self)
if response['success']:
user_data = response['data'][0]
response = NoteService().collaborator(user_data=user_data)
Response(self).jsonResponse(status=200, data=response)
def get_annotations(self, key):
url = urlparse.urljoin(self.endpoint.base_url,
'monitors/annotations/' + key)
resp = self.endpoint.get(url)
return Response(resp, self.endpoint)
async def request(self, client, addr):
request = (await self.loop.sock_recv(
client, self.SOCKET_BUFFER_SIZE)).decode('utf-8')
if not self.reqParser(request):
response = Response(400, setHeaders())
await self.loop.sock_sendall(client, str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
client.close()
return
if self.reqParser.requestLine.method not in self.ALLOWED_METHODS:
response = Response(405, setHeaders())
await self.loop.sock_sendall(client, str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
client.close()
return
pathToFile = os.path.abspath(
os.path.join(self.document_root, self.reqParser.requestLine.path))
pathToFile = unquote(pathToFile)
incorrectFile = (not pathToFile.endswith('/')
) and self.reqParser.requestLine.path.endswith('/')
if self.document_root not in pathToFile:
response = Response(403, setHeaders())
await self.loop.sock_sendall(client, str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
client.close()
return
isAdded = False
if os.path.isdir(pathToFile):
isAdded = True
pathToFile = os.path.join(
pathToFile, self.reqParser.requestLine.INDEX_FILE_NAME)
if not os.path.exists(pathToFile):
if isAdded:
response = Response(403, setHeaders())
else:
response = Response(404, setHeaders())
await self.loop.sock_sendall(client, str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
else:
if incorrectFile and not isAdded:
response = Response(404, setHeaders())
await self.loop.sock_sendall(client,
str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
else:
headers = setHeaders()
headers.append(
('Content-Length', str(os.path.getsize(pathToFile))))
mimeType, _ = mimetypes.guess_type(pathToFile)
headers.append(('Content-Type', mimeType))
response = Response(200, headers)
if self.reqParser.requestLine.method == 'HEAD':
await self.loop.sock_sendall(client,
str(response).encode('utf-8'))
await self.loop.sock_sendall(client, None)
else:
with open(pathToFile, 'rb') as fp:
await self.loop.sock_sendall(
client,
str(response).encode('utf-8'))
await self.loop.sock_sendall(
client, fp.read(self.SOCKET_BUFFER_SIZE))
client.close()
def info():
cpu_use = psutil.cpu_percent()
mem_use = psutil.virtual_memory().percent
response = Response(data={'cpu_use': cpu_use, 'mem_use': mem_use})
return response.to_json()
def add_qedge(self, message, input_parameters, describe=False):
"""
Adds a new QEdge object to the QueryGraph inside the Message object
:return: Response object with execution information
:rtype: Response
"""
# #### Internal documentation setup
allowable_parameters = {
'id': {
'Any string that is unique among all QEdge id fields, with recommended format e00, e01, e02, etc.'
},
'source_id': {
'id of the source QNode already present in the QueryGraph (e.g. n01, n02)'
},
'target_id': {
'id of the target QNode already present in the QueryGraph (e.g. n01, n02)'
},
'type': {
'Any valid Translator/BioLink relationship type (e.g. physically_interacts_with, participates_in)'
},
}
if describe:
#allowable_parameters['action'] = { 'None' }
#allowable_parameters = dict()
allowable_parameters[
'dsl_command'] = '`add_qedge()`' # can't get this name at run-time, need to manually put it in per https://www.python.org/dev/peps/pep-3130/
allowable_parameters[
'brief_description'] = """The `add_qedge` method adds an additional QEdge to the QueryGraph in the Message object. Currently
source_id and target_id QNodes must already be present in the QueryGraph. The specified type is not currently checked that it is a
valid Translator/BioLink relationship type, but it should be."""
return allowable_parameters
#### Define a default response
response = Response()
self.response = response
self.message = message
#### Basic checks on arguments
if not isinstance(input_parameters, dict):
response.error("Provided parameters is not a dict",
error_code="ParametersNotDict")
return response
#### Define a complete set of allowed parameters and their defaults
parameters = {
'id': None,
'source_id': None,
'target_id': None,
'type': None,
}
#### Loop through the input_parameters and override the defaults and make sure they are allowed
for key, value in input_parameters.items():
if key not in parameters:
response.error(f"Supplied parameter {key} is not permitted",
error_code="UnknownParameter")
else:
parameters[key] = value
#### Return if any of the parameters generated an error (showing not just the first one)
if response.status != 'OK':
return response
#### Store these final parameters for convenience
response.data['parameters'] = parameters
self.parameters = parameters
#### Now apply the filters. Order of operations is probably quite important
#### Scalar value filters probably come first like minimum_confidence, then complex logic filters
#### based on edge or node properties, and then finally maximum_results
response.info(
f"Adding a QueryEdge to Message with parameters {parameters}")
#### Make sure there's a query_graph already here
if message.query_graph is None:
message.query_graph = QueryGraph()
message.query_graph.nodes = []
message.query_graph.edges = []
if message.query_graph.edges is None:
message.query_graph.edges = []
#### Create a QEdge
qedge = QEdge()
if parameters['id'] is not None:
id = parameters['id']
else:
id = self.__get_next_free_edge_id()
qedge.id = id
#### Get the list of available node_ids
qnodes = message.query_graph.nodes
ids = {}
for qnode in qnodes:
id = qnode.id
ids[id] = 1
#### Add the source_id
if parameters['source_id'] is not None:
if parameters['source_id'] not in ids:
response.error(
f"While trying to add QEdge, there is no QNode with id {parameters['source_id']}",
error_code="UnknownSourceId")
return response
qedge.source_id = parameters['source_id']
else:
response.error(
f"While trying to add QEdge, source_id is a required parameter",
error_code="MissingSourceId")
return response
#### Add the target_id
if parameters['target_id'] is not None:
if parameters['target_id'] not in ids:
response.error(
f"While trying to add QEdge, there is no QNode with id {parameters['target_id']}",
error_code="UnknownTargetId")
return response
qedge.target_id = parameters['target_id']
else:
response.error(
f"While trying to add QEdge, target_id is a required parameter",
error_code="MissingTargetId")
return response
#### Add the type if any. Need to verify it's an allowed type. FIXME
if parameters['type'] is not None:
qedge.type = parameters['type']
#### Add it to the query_graph edge list
message.query_graph.edges.append(qedge)
#### Return the response
return response
def main():
#### Create a response object
response = Response()
#### Create a default ARAX Message
messenger = ARAXMessenger()
result = messenger.create_message()
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
message = messenger.message
#### Some qnode examples
parameters_sets = [
# { 'curie': 'DOID:9281'},
{
'curie': 'Orphanet:673'
},
{
'name': 'acetaminophen'
},
{
'curie': 'NCIT:C198'
},
{
'curie': 'CUI:C4710278'
},
{
'type': 'protein',
'id': 'n10'
},
{
'curie': ['UniProtKB:P14136', 'UniProtKB:P35579']
},
{
'curie': ['UniProtKB:P14136', 'UniProtKB:P35579'],
'is_set': 'false'
},
]
for parameter in parameters_sets:
#### Add a QNode
result = messenger.add_qnode(message, parameter)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
#### Some qedge examples
parameters_sets = [
{
'source_id': 'n00',
'target_id': 'n01'
},
{
'source_id': 'n01',
'target_id': 'n10',
'type': 'treats'
},
]
for parameter in parameters_sets:
#### Add a QEdge
result = messenger.add_qedge(message, parameter)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
if 0:
result = messenger.reassign_curies(message, {
'knowledge_provider': 'KG1',
'mismap_result': 'WARNING'
})
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
#### Show the final result
print(response.show(level=Response.DEBUG))
print(json.dumps(ast.literal_eval(repr(message)), sort_keys=True,
indent=2))
def handle_discovery(request):
response = Response(ResponseName.DISCOVER)
response.add_payload({"endpoints": api.get_endpoints()})
return response
def home_controller(request):
body = home_view.render()
return Response('200 OK', body)
def delete_user_impl(args):
try:
db.session.delete(user_by_user_id(args['user_id']))
return Response(True, "User Deleted", None).output()
except Exception as e:
return Response(False, str(e), None).output()
def handle_authentication(request):
return Response(ResponseName.ACCEPT_GRANT)
def app(request: Request) -> Response:
return Response(content="Hello!")
def auth_handler(request: Request) -> Response:
authorization = request.headers.get("authorization", "")
if authorization.startswith(
"Bearer ") and authorization[len("Bearer "):] == "opensesame":
return handler(request)
return Response(status="403 Forbidden", content="Forbidden!")
def get_response(self):
if self.request.method in ['GET', 'HEAD']:
response = self.make_response()
else:
response = Response(ResponseCode.NOT_ALLOWED)
return response.create_response()
def handle_one_request(self):
response = None
self.logger = get_logger()
try:
self.close_connection = False
request_line_is_valid = self.get_request_line()
if self.close_connection:
return
request_is_valid = self.parse_request()
if not request_is_valid:
#parse_request() actually sends its own error responses
return
self.server.rewriter.rewrite(self)
request = Request(self)
response = Response(self, request)
if request.method == "CONNECT":
self.handle_connect(response)
return
if not request_line_is_valid:
response.set_error(414)
response.write()
return
self.logger.debug("%s %s" % (request.method, request.request_path))
handler = self.server.router.get_handler(request)
# If the handler we used for the request had a non-default base path
# set update the doc_root of the request to reflect this
if hasattr(handler, "base_path") and handler.base_path:
request.doc_root = handler.base_path
if hasattr(handler, "url_base") and handler.url_base != "/":
request.url_base = handler.url_base
if self.server.latency is not None:
if callable(self.server.latency):
latency = self.server.latency()
else:
latency = self.server.latency
self.logger.warning("Latency enabled. Sleeping %i ms" %
latency)
time.sleep(latency / 1000.)
if handler is None:
response.set_error(404)
else:
try:
handler(request, response)
except HTTPException as e:
response.set_error(e.code, e.message)
except Exception as e:
if e.message:
err = [e.message]
else:
err = []
err.append(traceback.format_exc())
response.set_error(500, "\n".join(err))
self.logger.debug(
"%i %s %s (%s) %i" %
(response.status[0], request.method, request.request_path,
request.headers.get('Referer'), request.raw_input.length))
if not response.writer.content_written:
response.write()
# If we want to remove this in the future, a solution is needed for
# scripts that produce a non-string iterable of content, since these
# can't set a Content-Length header. A notable example of this kind of
# problem is with the trickle pipe i.e. foo.js?pipe=trickle(d1)
if response.close_connection:
self.close_connection = True
if not self.close_connection:
# Ensure that the whole request has been read from the socket
request.raw_input.read()
except socket.timeout, e:
self.log_error("Request timed out: %r", e)
self.close_connection = True
return
def upload_controller(request):
# TODO
body = upload_view.render()
return Response('200 OK', body)
def add_qnode(self, message, input_parameters, describe=False):
"""
Adds a new QNode object to the QueryGraph inside the Message object
:return: Response object with execution information
:rtype: Response
"""
# #### Internal documentation setup
allowable_parameters = {
'id': {
'Any string that is unique among all QNode id fields, with recommended format n00, n01, n02, etc.'
},
'curie': {
'Any compact URI (CURIE) (e.g. DOID:9281) (May also be a list like [UniProtKB:P12345,UniProtKB:Q54321])'
},
'name': {
'Any name of a bioentity that will be resolved into a CURIE if possible or result in an error if not (e.g. hypertension, insulin)'
},
'type': {
'Any valid Translator bioentity type (e.g. protein, chemical_substance, disease)'
},
'is_set': {
'If set to true, this QNode represents a set of nodes that are all in common between the two other linked QNodes'
},
}
if describe:
allowable_parameters[
'dsl_command'] = '`add_qnode()`' # can't get this name at run-time, need to manually put it in per https://www.python.org/dev/peps/pep-3130/
allowable_parameters[
'brief_description'] = """The `add_qnode` method adds an additional QNode to the QueryGraph in the Message object. Currently
when a curie or name is specified, this method will only return success if a matching node is found in the KG1/KG2 KGNodeIndex."""
return allowable_parameters
#### Define a default response
response = Response()
self.response = response
self.message = message
#### Basic checks on arguments
if not isinstance(input_parameters, dict):
response.error("Provided parameters is not a dict",
error_code="ParametersNotDict")
return response
#### Define a complete set of allowed parameters and their defaults
parameters = {
'id': None,
'curie': None,
'name': None,
'type': None,
'is_set': None,
}
#### Loop through the input_parameters and override the defaults and make sure they are allowed
for key, value in input_parameters.items():
if key not in parameters:
response.error(f"Supplied parameter {key} is not permitted",
error_code="UnknownParameter")
else:
parameters[key] = value
#### Return if any of the parameters generated an error (showing not just the first one)
if response.status != 'OK':
return response
#### Store these final parameters for convenience
response.data['parameters'] = parameters
self.parameters = parameters
#### Now apply the filters. Order of operations is probably quite important
#### Scalar value filters probably come first like minimum_confidence, then complex logic filters
#### based on edge or node properties, and then finally maximum_results
response.info(
f"Adding a QueryNode to Message with parameters {parameters}")
#### Make sure there's a query_graph already here
if message.query_graph is None:
message.query_graph = QueryGraph()
message.query_graph.nodes = []
message.query_graph.edges = []
if message.query_graph.nodes is None:
message.query_graph.nodes = []
#### Set up the KGNodeIndex
kgNodeIndex = KGNodeIndex()
# Create the QNode and set the id
qnode = QNode()
if parameters['id'] is not None:
id = parameters['id']
else:
id = self.__get_next_free_node_id()
qnode.id = id
# Set the is_set parameter to what the user selected
if parameters['is_set'] is not None:
qnode.is_set = (parameters['is_set'].lower() == 'true')
#### If the CURIE is specified, try to find that
if parameters['curie'] is not None:
# If the curie is a scalar then treat it here as a list of one
if isinstance(parameters['curie'], str):
curie_list = [parameters['curie']]
is_curie_a_list = False
if parameters['is_set'] is not None and qnode.is_set is True:
response.error(
f"Specified CURIE '{parameters['curie']}' is a scalar, but is_set=true, which doesn't make sense",
error_code="CurieScalarButIsSetTrue")
return response
# Or else set it up as a list
elif isinstance(parameters['curie'], list):
curie_list = parameters['curie']
is_curie_a_list = True
qnode.curie = []
if parameters['is_set'] is None:
response.warning(
f"Specified CURIE '{parameters['curie']}' is a list, but is_set was not set to true. It must be true in this context, so automatically setting to true. Avoid this warning by explictly setting to true."
)
qnode.is_set = True
else:
if qnode.is_set == False:
response.warning(
f"Specified CURIE '{parameters['curie']}' is a list, but is_set=false, which doesn't make sense, so automatically setting to true. Avoid this warning by explictly setting to true."
)
qnode.is_set = True
# Or if it's neither a list or a string, then error out. This cannot be handled at present
else:
response.error(
f"Specified CURIE '{parameters['curie']}' is neither a string nor a list. This cannot to handled",
error_code="CurieNotListOrScalar")
return response
# Loop over the available curies and create the list
for curie in curie_list:
response.debug(f"Looking up CURIE {curie} in KgNodeIndex")
nodes = kgNodeIndex.get_curies_and_types(curie, kg_name='KG2')
# If nothing was found, we won't bail out, but rather just issue a warning
if len(nodes) == 0:
response.warning(
f"A node with CURIE {curie} is not in our knowledge graph KG2, but will continue"
)
if is_curie_a_list:
qnode.curie.append(curie)
else:
qnode.curie = curie
else:
# FIXME. This is just always taking the first result. This could cause problems for CURIEs with multiple types. Is that possible?
# In issue #623 on 2020-06-15 we concluded that we should not specify the type here
#qnode.type = nodes[0]['type']
# Either append or set the found curie
if is_curie_a_list:
qnode.curie.append(nodes[0]['curie'])
else:
qnode.curie = nodes[0]['curie']
if 'type' in parameters and parameters['type'] is not None:
if isinstance(parameters['type'], str):
qnode.type = parameters['type']
else:
qnode.type = parameters['type'][0]
message.query_graph.nodes.append(qnode)
return response
#### If the name is specified, try to find that
if parameters['name'] is not None:
response.debug(
f"Looking up CURIE {parameters['name']} in KgNodeIndex")
nodes = kgNodeIndex.get_curies_and_types(parameters['name'])
if len(nodes) == 0:
nodes = kgNodeIndex.get_curies_and_types(parameters['name'],
kg_name='KG2')
if len(nodes) == 0:
response.error(
f"A node with name '{parameters['name']}'' is not in our knowledge graph",
error_code="UnknownCURIE")
return response
qnode.curie = nodes[0]['curie']
qnode.type = nodes[0]['type']
message.query_graph.nodes.append(qnode)
return response
#### If the type is specified, just add that type. There should be checking that it is legal. FIXME
if parameters['type'] is not None:
qnode.type = parameters['type']
if parameters['is_set'] is not None:
qnode.is_set = (parameters['is_set'].lower() == 'true')
message.query_graph.nodes.append(qnode)
return response
#### If we get here, it means that all three main parameters are null. Just a generic node with no type or anything. This is okay.
message.query_graph.nodes.append(qnode)
return response
class Request(object):
"""Class that represents a request to PiCloud.
:param str url: A URL to be fetched.
:param str method: Target HTTP method.
("GET" or "POST" or "PUT" or "DELETE" or "HEAD" or "OPTIONS")
:param dict headers: (optional) HTTP headers to send.
:param dict args: (optional) Additional arguments, that are directly passed
to `requests <http://docs.python-requests.org>`_. Any arguments that
supported in `requests <http://docs.python-requests.org>`_ are supported.
:param function success_callback: (optional) A function called if the
request is successfully completed.
A :class:`Response <picrawler.response.Response>` instance is passed as
the first argument.
:param function error_callback: (optional) A function called if the request
is failed. An :class:`ErrorResponse <picrawler.response.ErrorResponse>`
instance is passed as the first argument.
"""
def __init__(self,
url,
method='get',
headers={},
args={},
success_callback=None,
error_callback=None):
global _success_callbacks, _error_callbacks
self._id = uuid.uuid1().hex
self._url = url
self._method = method.lower()
self._headers = headers
self._args = args
self._success_callback_id = None
self._error_callback_id = None
if not self._method in SUPPORTED_HTTP_METHODS:
raise InvalidHTTPMethod('Unsupported HTTP method')
# NOTE: because the callback function cannot be pickled,
# it must be saved locally
if success_callback:
self._success_callback_id = uuid.uuid1().hex
_success_callbacks[self._success_callback_id] = success_callback
if error_callback:
self._error_callback_id = uuid.uuid1().hex
_error_callbacks[self._error_callback_id] = error_callback
@property
def id(self):
return self._id
@property
def url(self):
return self._url
@property
def method(self):
return self._method
@property
def headers(self):
return self._headers
@property
def args(self):
return self._args
@property
def success_callback(self):
global _success_callbacks
if self._success_callback_id:
return _success_callbacks.get(self._success_callback_id)
else:
return None
@property
def error_callback(self):
global _error_callbacks
if self._error_callback_id:
return _error_callbacks.get(self._error_callback_id)
else:
return None
def run_callback(self, response):
global _success_callbacks, _error_callbacks
if isinstance(response, Response):
if self._success_callback_id:
_success_callbacks[self._success_callback_id](response)
elif isinstance(response, ErrorResponse):
if self._error_callback_id:
_error_callbacks[self._error_callback_id](response)
else:
raise InvalidResponse('Invalid response')
def __call__(self):
method_func = getattr(requests, self._method)
try:
ret = method_func(self._url, headers=self._headers, **self._args)
except Exception, e:
return ErrorResponse(self, e)
return Response(self, ret.status_code, ret.content, ret.headers)
def reassign_curies(self, message, input_parameters, describe=False):
"""
Reassigns CURIEs to the target Knowledge Provider
:param message: Translator standard Message object
:type message: Message
:param input_parameters: Dict of input parameters to control the method
:type input_parameters: Message
:return: Response object with execution information
:rtype: Response
"""
# #### Internal documentation setup
allowable_parameters = {
'knowledge_provider': {
'Name of the Knowledge Provider CURIE space to map to. Default=KG1. Also currently supported KG2'
},
'mismap_result': {
'Desired action when mapping fails: ERROR or WARNING. Default is ERROR'
},
}
if describe:
allowable_parameters[
'dsl_command'] = '`reassign_curies()`' # can't get this name at run-time, need to manually put it in per https://www.python.org/dev/peps/pep-3130/
allowable_parameters[
'brief_description'] = """The `reassign_curies` method reassigns all the CURIEs in the Message QueryGraph to the specified
knowledge provider. Allowed values are KG1 or KG2. Default is KG1 if not specified."""
return allowable_parameters
#### Define a default response
response = Response()
self.response = response
self.message = message
#### Basic checks on arguments
if not isinstance(input_parameters, dict):
response.error("Provided parameters is not a dict",
error_code="ParametersNotDict")
return response
#### Define a complete set of allowed parameters and their defaults
parameters = {
'knowledge_provider': 'KG1',
'mismap_result': 'ERROR',
}
#### Loop through the input_parameters and override the defaults and make sure they are allowed
for key, value in input_parameters.items():
if key not in parameters:
response.error(f"Supplied parameter {key} is not permitted",
error_code="UnknownParameter")
else:
parameters[key] = value
#### Return if any of the parameters generated an error (showing not just the first one)
if response.status != 'OK':
return response
#### Store these final parameters for convenience
response.data['parameters'] = parameters
self.parameters = parameters
# Check that the knowledge_provider is valid:
if parameters['knowledge_provider'] != 'KG1' and parameters[
'knowledge_provider'] != 'KG2':
response.error(
f"Specified knowledge provider must be 'KG1' or 'KG2', not '{parameters['knowledge_provider']}'",
error_code="UnknownKP")
return response
#### Now try to assign the CURIEs
response.info(
f"Reassigning the CURIEs in QueryGraph to {parameters['knowledge_provider']} space"
)
#### Make sure there's a query_graph already here
if message.query_graph is None:
message.query_graph = QueryGraph()
message.query_graph.nodes = []
message.query_graph.edges = []
if message.query_graph.nodes is None:
message.query_graph.nodes = []
#### Set up the KGNodeIndex
kgNodeIndex = KGNodeIndex()
# Loops through the QueryGraph nodes and adjust them
for qnode in message.query_graph.nodes:
# If the CURIE is None, then there's nothing to do
curie = qnode.curie
if curie is None:
continue
# Map the CURIE to the desired Knowledge Provider
if parameters['knowledge_provider'] == 'KG1':
if kgNodeIndex.is_curie_present(curie) is True:
mapped_curies = [curie]
else:
mapped_curies = kgNodeIndex.get_KG1_curies(curie)
elif parameters['knowledge_provider'] == 'KG2':
if kgNodeIndex.is_curie_present(curie, kg_name='KG2'):
mapped_curies = [curie]
else:
mapped_curies = kgNodeIndex.get_curies_and_types(
curie, kg_name='KG2')
else:
response.error(
f"Specified knowledge provider must be 'KG1' or 'KG2', not '{parameters['knowledge_provider']}'",
error_code="UnknownKP")
return response
# Try to find a new CURIE
new_curie = None
if len(mapped_curies) == 0:
if parameters['mismap_result'] == 'WARNING':
response.warning(
f"Did not find a mapping for {curie} to KP '{parameters['knowledge_provider']}'. Leaving as is"
)
else:
response.error(
f"Did not find a mapping for {curie} to KP '{parameters['knowledge_provider']}'. This is an error"
)
elif len(mapped_curies) == 1:
new_curie = mapped_curies[0]
else:
original_curie_is_fine = False
for potential_curie in mapped_curies:
if potential_curie == curie:
original_curie_is_fine = True
if original_curie_is_fine:
new_curie = curie
else:
new_curie = mapped_curies[0]
response.warning(
f"There are multiple possible CURIEs in KP '{parameters['knowledge_provider']}'. Selecting the first one {new_curie}"
)
# If there's no CURIE, then nothing to do
if new_curie is None:
pass
# If it's the same
elif new_curie == curie:
response.debug(
f"CURIE {curie} is fine for KP '{parameters['knowledge_provider']}'"
)
else:
response.info(
f"Remapping CURIE {curie} to {new_curie} for KP '{parameters['knowledge_provider']}'"
)
#### Return the response
return response
def run(config, debug):
global _settings, _logger
programExecTime = time.time()
outData = []
_settings = Settings(config)
if debug == True:
_logger = sys.stdout.write
elif type(debug) == str:
try:
logFile = open(debug, "a")
_logger = logFile.write
except Exception as e:
print('\nCannot open log file. Debug flag ignored. Error: ' +
str(e))
try:
startTime = time.time()
loginStatus = login()
if not (loginStatus):
loginResponse = Response('sasping login request',
'fail',
message='Failed to login.')
else:
loginResponse = Response('sasping login request', 'success')
except requests.exceptions.Timeout as err:
loginResponse = Response('sasping login request',
'fail',
message='Request timeout')
loginResponse.setTime(startTime, time.time() - startTime)
loginResponse.setProgramExecTime(programExecTime)
if loginResponse.status == 'fail':
return [dict(loginResponse)]
# get request to do sas security check
# this request is not logged to csv file
try:
_session.get(
_settings.get('hostUrl') +
Test(_settings.get('applications')[0]['tests'][0]).get('execPath'))
except requests.exceptions.RequestException:
raise RuntimeError('SAS security check request failed')
finally:
outData.append(dict(loginResponse.setProgramExecTime(programExecTime)))
applications = _settings.get('applications')
for app in applications:
for test in [Test(testConfig) for testConfig in app['tests']]:
try:
startTime = time.time()
response = call(test)
except requests.exceptions.Timeout:
response = Response(test.get('id'),
'fail',
message='Request timeout')
except requests.exceptions.ConnectionError:
response = Response(test.get('id'),
'fail',
message='Name or service not known')
except requests.exceptions.RequestException as e:
response = Response(test.get('id'), 'fail', message=str(e))
response.setTime(startTime, time.time() - startTime)
response.setAppName(app['name'])
outData.append(
dict(response.setProgramExecTime(programExecTime)))
try:
logFile.close()
finally:
return outData
def main():
### Note that most of this is just manually doing what ARAXQuery() would normally do for you
#### 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 = [
# "overlay(compute_confidence_scores=true)",
# "return(message=true,store=false)"
# ]
actions_list = [
#"filter_kg(action=remove_edges_by_type, edge_type=physically_interacts_with, remove_connected_nodes=false)",
#"filter_kg(action=remove_edges_by_type, edge_type=physically_interacts_with, remove_connected_nodes=something)",
#"filter(action=remove_nodes_by_type, node_type=protein)",
#"overlay(action=compute_ngd)",
#"filter(action=remove_edges_by_attribute, edge_attribute=ngd, threshold=.63, direction=below, remove_connected_nodes=t)",
#"filter(action=remove_edges_by_attribute, edge_attribute=ngd, threshold=.6, remove_connected_nodes=False)",
"filter(action=remove_orphaned_nodes)",
"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) # acetaminophen2proteins graph
# message_dict = araxdb.getMessage(13) # ibuprofen -> proteins -> disease # work computer
# message_dict = araxdb.getMessage(14) # pleuropneumonia -> phenotypic_feature # work computer
# message_dict = araxdb.getMessage(16) # atherosclerosis -> phenotypic_feature # work computer
# message_dict = araxdb.getMessage(5) # atherosclerosis -> phenotypic_feature # home computer
# message_dict = araxdb.getMessage(10)
message_dict = araxdb.getMessage(40)
#### The stored message comes back as a dict. Transform it to objects
from ARAX_messenger import ARAXMessenger
message = ARAXMessenger().from_dict(message_dict)
# print(json.dumps(ast.literal_eval(repr(message)),sort_keys=True,indent=2))
#### Create an overlay object and use it to apply action[0] from the list
#filterkg = ARAXFilterKG()
#result = filterkg.apply(message, actions[0]['parameters'])
#response.merge(result)
# Apply overlay so you get an edge attribute to work with, then apply the filter
#from ARAX_overlay import ARAXOverlay
#overlay = ARAXOverlay()
#result = overlay.apply(message, actions[0]['parameters'])
#response.merge(result)
# then apply the filter
filterkg = ARAXFilterKG()
result = filterkg.apply(message, actions[0]['parameters'])
response.merge(result)
# if result.status != 'OK':
# print(response.show(level=Response.DEBUG))
# return response
# response.data = result.data
#### If successful, show the result
# 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 }
# response.data['message_stats']['confidence_scores'] = []
# for result in message.results:
# response.data['message_stats']['confidence_scores'].append(result.confidence)
# print(json.dumps(ast.literal_eval(repr(response.data['parameters'])),sort_keys=True,indent=2))
# print(json.dumps(ast.literal_eval(repr(response.data['message_stats'])),sort_keys=True,indent=2))
# a comment on the end so you can better see the network on github
# look at the response
# print(response.show(level=Response.DEBUG))
# print(response.show())
# print("Still executed")
# look at the edges
# print(json.dumps(ast.literal_eval(repr(message.knowledge_graph.edges)),sort_keys=True,indent=2))
# print(json.dumps(ast.literal_eval(repr(message.knowledge_graph.nodes)), sort_keys=True, indent=2))
# print(json.dumps(ast.literal_eval(repr(message)), sort_keys=True, indent=2))
# print(response.show(level=Response.DEBUG))
# just print off the values
# print(json.dumps(ast.literal_eval(repr(message.knowledge_graph.edges)), sort_keys=True, indent=2))
# for edge in message.knowledge_graph.edges:
# if hasattr(edge, 'edge_attributes') and edge.edge_attributes and len(edge.edge_attributes) >= 1:
# print(edge.edge_attributes.pop().value)
print(
json.dumps(ast.literal_eval(repr(message.knowledge_graph.edges)),
sort_keys=True,
indent=2))
print(response.show(level=Response.DEBUG))
vals = []
for node in message.knowledge_graph.nodes:
print(node.id)
print(len(message.knowledge_graph.nodes))
for edge in message.knowledge_graph.edges:
if hasattr(edge, 'edge_attributes') and edge.edge_attributes and len(
edge.edge_attributes) >= 1:
vals.append(edge.edge_attributes.pop().value)
print(sorted(vals))
def main():
#### Create a response object
response = Response()
#### 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
messenger = ARAXMessenger()
message = messenger.from_dict(message_dict)
#### Asses some information about the QueryGraph
query_graph_info = QueryGraphInfo()
result = query_graph_info.assess(message)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
#print(json.dumps(ast.literal_eval(repr(query_graph_info.node_order)),sort_keys=True,indent=2))
#### Try to add query_graph_ids to the KnowledgeGraph
knowledge_graph_info = KnowledgeGraphInfo()
result = knowledge_graph_info.add_query_graph_tags(message,
query_graph_info)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
#### Reassess some information about the KnowledgeGraph
result = knowledge_graph_info.check_for_query_graph_tags(
message, query_graph_info)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
#### Try to re-create the results list
result = messenger.generate_results(message)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
print(response.show(level=Response.DEBUG))
tmp = {
'query_graph_id_node_status':
knowledge_graph_info.query_graph_id_node_status,
'query_graph_id_edge_status':
knowledge_graph_info.query_graph_id_edge_status,
'n_nodes': knowledge_graph_info.n_nodes,
'n_edges': knowledge_graph_info.n_edges
}
#print(json.dumps(ast.literal_eval(repr(message)),sort_keys=True,indent=2))
print(json.dumps(ast.literal_eval(repr(tmp)), sort_keys=True, indent=2))
-1.703608E-02 + 1.234000E-02j, -1.703608E-02 + -1.234000E-02j,
-1.778991e-02 + 0.000000e-00j, -5.605308e-02 + 0.000000e-00j,
-3.918000E+01 + 4.912000E+01j, -3.918000E+01 + -4.912000E+01j
]
# this is from sensor test suite
zer3 = [0.000000E+00 + 0.000000E+00j, 0.000000E+00 + 0.000000E+00j]
pol3 = [
-1.263000E-02 + 1.265000E-02j, -1.263000E-02 + -1.265000E-02j,
-3.620107E+01 + 6.850121E+01j, -3.620107E+01 + -6.850121E+01j
]
instName = 'CTAO_00'
print("calculating info for a " + instName)
inst1 = Response(desc=instName, units='Radians')
inst1.zeros = zer1
inst1.poles = pol1
#norm_freq=0.02
norm_freq = 1.0
n1, f1 = inst1.check_normalization(freq=norm_freq, nfft=2**26, t_sample=0.001)
scale_fac = 1.0 / n1
print('The A0 norm factor is: ' + str(scale_fac) + ' for f=' + str(norm_freq))
#check the value
inst1.a0 = 1.0 / n1
A01 = inst1.a0
n, f = inst1.check_normalization(freq=norm_freq, nfft=2**26, t_sample=0.001)
print('This should be close to 1: ' + str(1.0 / n))
h1, f1 = paz_to_freq_resp(inst1.poles,
inst1.zeros,
scale_fac,
def __init__(self):
self.rsp = Response()
self.av_queue = queue.Queue()
self.max_threads = 5
class Server:
BAD_REQUEST = Response(code=HTTPResponseCodes.BAD_REQUEST,
content_type=HTTPContentTypes.PLAIN,
data='Failure'.encode())
UNAUTHORIZED = Response(code=HTTPResponseCodes.UNAUTHORIZED,
content_type=HTTPContentTypes.PLAIN,
data='Failure'.encode())
METHOD_NOT_ALLOWED = Response(code=HTTPResponseCodes.UNAUTHORIZED,
content_type=HTTPContentTypes.PLAIN,
data='Failure'.encode())
SUCCESS = Response(code=HTTPResponseCodes.OK,
content_type=HTTPContentTypes.PLAIN,
data='Success'.encode())
def __init__(self, host_ip=None, host_name=None, port=None):
if host_ip is None:
if host_name is None:
host_name = socket.gethostname()
if host_ip is None:
host_ip = "192.168.1.5" #socket.gethostbyname(host_name)
if port is None:
port = 7654
self.socket = socket.socket()
self.host_ip = host_ip
self.host_name = host_name
self.port = port
self.socket.bind((self.host_ip, self.port))
self.socket.listen(5)
def run(self):
while True:
client, address = self.socket.accept()
message = client.recv(4096)
self.communicate(client, address, message)
def communicate(self, client, address, message):
# PARSE REQUEST
req = Request(msg=message)
resp = None
console.info(
'Received {} request from {} at {} with {} parameters'.format(
req.method.name, address[0], req.path,
0 if req.params is None else len(req.params.keys())))
# CHECK TO MAKE SURE POST REQUEST WAS RECEIVED
if req.method == HTTPMethods.POST:
# CHECK TO MAKE SURE DATA WAS RECEIVED
if req.data is not None:
# CHECK TO MAKE SURE JSON HAS CORRECT FIELDS
if 'command' in req.data.keys() and 'key' in req.data.keys():
console.debug('Received command: {}'.format(
req.data['command']))
# AUTHENTICATE KEY
if req.data['key'] == settings.MASTER_KEY:
# CALL APPROPRIATE FUNCTION (OPEN/CLOSE)
if req.data['command'] == 0:
garage.open_g()
resp = self.SUCCESS
elif req.data['command'] == 1:
garage.close_g()
resp = self.SUCCESS
else:
resp = self.BAD_REQUEST
else:
resp = self.UNAUTHORIZED
else:
resp = self.BAD_REQUEST
else:
resp = self.BAD_REQUEST
else:
resp = self.METHOD_NOT_ALLOWED
# SEND RESPONSE
client.send(resp.generate())
# CLOSE CLIENT CONNECTION
client.close()
def _execute(self, goal):
"""Callback for serving Execute action requests.
"""
action_id = None
if goal.action_id != '':
action_id = goal.action_id
else:
action_id = self._action_db.id_for_name(goal.name)
self._interaction.switch_to_action_by_id(action_id)
response_params = self._interaction._execute_action(
preregistered_landmarks=goal.landmarks)
if RobotSpeech.START_EXECUTION not in response_params[0]:
result = ExecuteResult()
result.error = response_params[0]
self._server.set_aborted(result=result, text=result.error)
response = Response(self._interaction._empty_response,
response_params)
response.respond()
return
# Wait for it to start executing for at most 10 seconds
rate = rospy.Rate(10)
start = rospy.Time.now()
timeout = rospy.Duration(10)
while not self._interaction.arms.is_executing():
elapsed_time = rospy.Time.now() - start
if elapsed_time > timeout:
rospy.logwarn('PbD action did not start after 10 seconds')
result = ExecuteResult()
result.error = 'PbD action did not start after 10 seconds'
self._server.set_aborted(result=result, text=result.error)
break
rate.sleep()
response = Response(self._interaction._empty_response, response_params)
response.respond()
rate = rospy.Rate(10)
start = rospy.Time.now()
timeout = rospy.Duration(60 * 5)
while self._interaction.arms.is_executing():
elapsed_time = rospy.Time.now() - start
self._server.publish_feedback(ExecuteFeedback())
if elapsed_time > timeout:
rospy.logwarn('PbD action did not finish after 5 minutes')
result = ExecuteResult()
result.error = 'PbD action did not finish after 5 minutes'
self._server.set_aborted(result=result, text=result.error)
break
rate.sleep()
status = self._interaction.arms.last_status
if status == ExecutionStatus.SUCCEEDED:
rospy.loginfo('Execution succeeded')
self._server.set_succeeded()
elif status == ExecutionStatus.NOT_EXECUTING:
rospy.loginfo('Execution state was NOT_EXECUTING - failed?')
# Race condition? Assume this means failure.
error = 'Unable to run the PbD action.'
result = ExecuteResult()
result.error = error
rospy.logerr(error)
self._server.set_aborted(result=result, text=error)
elif status == ExecutionStatus.PREEMPTED:
error = 'The PbD action was preempted.'
result = ExecuteResult()
result.error = error
rospy.logerr(error)
self._server.set_aborted(result=result, text=error)
elif status == ExecutionStatus.NO_IK:
error = 'The robot\'s arms couldn\'t reach some poses.'
result = ExecuteResult()
result.error = error
rospy.logerr(error)
self._server.set_aborted(result=result, text=error)
else:
error = 'Unknown error {} running the PbD action'.format(status)
result = ExecuteResult()
result.error = error
rospy.logerr(error)
self._server.set_aborted(result=result, text=error)
def delete_rule(self, key):
url = urlparse.urljoin(self.endpoint.base_url, 'monitors/' + key)
resp = self.endpoint.delete(url)
return Response(resp, self.endpoint)
import numpy as np
import matplotlib.pyplot as plt
from obspy.signal.invsim import paz_to_freq_resp
from response import Response
pol = [
-0.01234 - 1j * 0.01234, -0.01234 + 1j * 0.01234, -39.18 - 1j * 49.12,
-39.18 + 1j * 49.12
]
zer = [0, 0]
# use Austin's response class to build the resp from the poles and zeros
inst = Response(desc='STS-5/360', units='Radians')
inst.zeros = zer
inst.poles = pol
norm_freq = 1.0
n, f = inst.check_normalization(freq=norm_freq, nfft=2**26, t_sample=0.001)
scale_fac = 1.0 / n
print('The A0 norm factor is: ' + str(scale_fac))
#poles = [-4.440 + 4.440j, -4.440 - 4.440j, -1.083 + 0.0j]
#zeros = [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j]
scale_fac = 0.4
h, f = paz_to_freq_resp(inst.poles,
inst.zeros,
scale_fac,
0.001,
2**26,
freq=True)
def get_changelog(self, key):
url = urlparse.urljoin(self.endpoint.base_url,
'monitors/%s/changes/' % key)
resp = self.endpoint.get(url)
return Response(resp, self.endpoint)
def about(request, p):
return Response("{} about page".format(request.request_uri))
