def test_descendants():
toolkit = Toolkit()
assert 'causes' in toolkit.get_descendants('related to')
assert 'interacts with' in toolkit.get_descendants('related to')
assert 'gene' in toolkit.get_descendants('named thing')
assert 'phenotypic feature' in toolkit.get_descendants('named thing')
assert 'biolink:PhenotypicFeature' in toolkit.get_descendants(
'named thing', formatted=True)
assert 'genomic entity' in toolkit.get_ancestors('genomic entity')
assert 'genomic entity' in toolkit.get_ancestors('genomic entity',
reflexive=True)
assert 'genomic entity' not in toolkit.get_ancestors('genomic entity',
reflexive=False)
assert 'biolink:GenomicEntity' in toolkit.get_ancestors('gene',
formatted=True)
assert 'gross anatomical structure' in toolkit.get_ancestors(
'tissue', reflexive=True)
assert 'molecular activity_has output' not in toolkit.get_descendants(
'molecular activity', reflexive=True)
assert 'molecular activity_has output' not in toolkit.get_descendants(
'has output', reflexive=True)
def load_edges(g: nx.Graph):
"""
http://34.229.55.225/edges_neo4j.csv
CSV row example:
SEMMED_PRED,pmids,negated,:TYPE,:START_ID,:END_ID,n_pmids,is_defined_by,relation,provided_by
AFFECTS,20801151,False,affects,UMLS:C1412045,UMLS:C0023946,1,semmeddb,semmeddb:affects,semmeddb_sulab
"""
df = pd.read_csv('data/semmeddb_edges.csv')
toolkit = Toolkit()
def process_row(row):
p = row['pmids']
p = ['PMID:' + i for i in p.split(';')] if p is not None else None
t = row[':TYPE'].replace(' ', '_')
if toolkit.is_edgelabel(t):
edge_label = t
else:
edge_label = 'related_to'
kwargs = dict(
publications=p,
negated=row['negated'],
edge_label=edge_label,
defined_by=row['is_defined_by'],
provided_by=[row['provided_by']],
relation=row['relation'],
)
g.add_edge(row[':START_ID'], row[':END_ID'], **kwargs)
df.apply(process_row, axis=1)
from bmt import Toolkit
from fastapi import Body
from fastapi.exceptions import HTTPException
from fastapi.responses import JSONResponse
import httpx
from reasoner_pydantic import Query as ReasonerQuery, Response
from starlette.middleware.cors import CORSMiddleware
from starlette.requests import Request
from .config import settings
from .identifiers import map_identifiers
from .util import load_example
from .trapi import TRAPI
BMT = Toolkit()
openapi_kwargs = dict(
title="ROBOKOP ARA",
version="2.6.3",
terms_of_service="N/A",
translator_component="ARA",
translator_teams=["Ranking Agent"],
contact={
"name": "Kenneth Morton",
"email": "*****@*****.**",
"x-id": "kennethmorton",
"x-role": "responsible developer",
},
openapi_tags=[{
"name": "robokop"
"""MATCHing tools."""
from typing import Dict, List
from bmt import Toolkit
from .nesting import Query
from .util import ensure_list, snake_case, space_case, pascal_case
bmt = Toolkit()
def cypher_prop_string(value):
"""Convert property value to cypher string representation."""
if isinstance(value, bool):
return str(value).lower()
if isinstance(value, str):
return "\"{0}\"".format(value.replace("\"", "\\\""))
if isinstance(value, (float, int)):
return str(value)
raise ValueError(f"Unsupported property type: {type(value).__name__}.")
class NodeReference():
"""Node reference object."""
def __init__(self, node_id, node, **kwargs):
"""Create a node reference.
All node properties of types [str, bool, float/int] will be enforced
verbatim EXCEPT for the following reserved properties:
* categories
* ids
def test_category():
toolkit = Toolkit()
assert toolkit.is_category('named thing')
assert toolkit.is_category('gene')
assert not toolkit.is_category('causes')
assert not toolkit.is_category('affects')
def test_predicate():
toolkit = Toolkit()
assert not toolkit.is_predicate('named thing')
assert not toolkit.is_predicate('gene')
assert toolkit.is_predicate('causes')
def test_get_all_slots_with_class_range():
toolkit = Toolkit()
assert 'treated by' in toolkit.get_all_slots_with_class_range('treatment')
assert 'biolink:treated_by' in toolkit.get_all_slots_with_class_range(
'treatment', formatted=True)
def test_get_all_slots_with_class_domain():
toolkit = Toolkit()
assert 'treats' in toolkit.get_all_slots_with_class_domain('treatment')
assert 'biolink:treats' in toolkit.get_all_slots_with_class_domain(
'treatment', formatted=True)
import pytest
import requests
from bmt import Toolkit
from reasoner_validator import validate_Message, ValidationError
#Toolkit takes a couple of seconds to initialize, so don't want it per-test
#note also that we are explictly controlling which version of biolink we are using.
tk = Toolkit(
'https://raw.githubusercontent.com/biolink/biolink-model/1.6.0/biolink-model.yaml'
)
def create_one_hop_message(edge, look_up_subject=False):
"""Given a complete edge, create a valid TRAPI message for querying for the edge.
if look_up_subject is False (default) then the object id is not included, (lookup object
by subject) and if look_up_subject is True, then the subject id is not included (look up
subject by object)"""
query_graph = {
"nodes": {
'a': {
"category": edge['subject_category']
},
'b': {
"category": edge['object_category']
}
},
"edges": {
'ab': {
"subject": "a",
"object": "b",
"predicate": edge['predicate']
This test module tests the COHD API by making requests to cohd.io/api and checking the schema of the response JSONs and
checking the results against known values.
Intended to be run with pytest: pytest -s test_cohd_trapi.py
"""
from collections import namedtuple
from itertools import product
import requests
import json as j
from bmt import Toolkit
from notebooks.cohd_helpers import cohd_requests as cr
from cohd.trapi import reasoner_validator_11x, reasoner_validator_10x
# Static instance of the Biolink Model Toolkit
bm_toolkit = Toolkit()
"""
tuple for storing pairs of (key, type) for results schemas
"""
_s = namedtuple('_s', ['key', 'type'])
# Choose which server to test
cr.server = 'https://cohd.io/api'
# Proxy for main TRAPI version
reasoner_validator = reasoner_validator_11x
translator_query = cr.translator_query_110
# No longer supporting TRAPI 1.0. Leaving this code block here so that we can re-use it later on when transitioning
# between TRAPI 1.1 to 1.2
# def test_translator_query_100():
def __init__(self):
super().__init__()
self.toolkit = Toolkit()
self.ecache: Dict = {}
def __init__(self, owner):
super().__init__(owner)
self.toolkit = Toolkit()
self.ecache: Dict = {}
def toolkit():
return Toolkit()
def __init__(self, bl_version='1.5.0'):
self.bl_url = f'https://raw.githubusercontent.com/biolink/biolink-model/{bl_version}/biolink-model.yaml'
self.toolkit = Toolkit(self.bl_url)
import json
import os
from bmt import Toolkit
bmt_toolkit = Toolkit()
# load the attrib and value mapping file
map_data = json.load(
open(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "..",
"..", "attr_val_map.json")))
# attribute skip list
skip_list = json.load(
open(
os.path.join(os.path.abspath(os.path.dirname(__file__)), "..", "..",
"..", "skip_attr.json")))
# set the value type mappings
VALUE_TYPES = map_data['value_type_map']
def get_attribute_bl_info(attribute_name):
# set defaults
new_attr_meta_data = {
"attribute_type_id": "biolink:Attribute",
"value_type_id": "EDAM:data_0006",
}
# if attribute is meant to b6e skipped return none
if attribute_name in skip_list or attribute_name in ["name", "id"]:
return None