def test_ecomap():
"""
test mappings between GAF codes and ECO
"""
m = EcoMap()
assert m.coderef_to_ecoclass('IEA', 'GO_REF:0000002') == 'ECO:0000256'
assert m.coderef_to_ecoclass('IEA') == 'ECO:0000501'
assert m.coderef_to_ecoclass('IEA', 'FAKE:ID') == 'ECO:0000501'
assert m.ecoclass_to_coderef('ECO:0000501') == ('IEA', None)
assert m.ecoclass_to_coderef('ECO:0000256') == ('IEA', 'GO_REF:0000002')
assert m.coderef_to_ecoclass('BADCODE', None) == None
assert m.coderef_to_ecoclass('BADCODE', 'GO_REF:xxx') == None
assert m.ecoclass_to_coderef('ECO:9999999999999999999') == (None, None)
assert m.coderef_to_ecoclass('ISO', None) == 'ECO:0000266'
class RdfTransform(object):
"""
base class for all RDF generators
"""
def __init__(self, writer=None):
if writer is None:
writer = TurtleRdfWriter()
self.writer = writer
self.include_subject_info = False
self.ecomap = EcoMap()
self._emit_header_done = False
self.uribase = writer.base
self.ecomap.mappings()
self.bad_chars_regex = re.compile("[^\.:_\-0-9a-zA-Z]")
self.ro_lookup = dict(relations.label_relation_lookup())
def blanknode(self):
return BNode()
def uri(self, id):
# allow either atoms or objects
if isinstance(id, dict):
return self.uri(id['id'])
# logger.info("Expand: {}".format(id))
id = self.bad_chars_regex.sub("_", id)
uri = curie_util.expand_uri(id, cmaps=[prefix_context])
if uri != id:
# If URI is different, then that means we found an curie expansion, and we should add the prefix
prefix = id.split(":")[0]
self.writer.graph.bind(prefix, prefix_context[prefix])
return URIRef(uri)
def lookup_relation(self, label):
label = label.replace('_', ' ')
# Return the cached label -> URI or None
if label in self.ro_lookup:
return self.uri(self.ro_lookup[label])
else:
return None
def emit(self, s, p, o):
logger.debug("TRIPLE: {} {} {}".format(s, p, o))
self.writer.add(s, p, o)
return (s, p, o)
def emit_type(self, s, t):
return self.emit(s, RDF.type, t)
def emit_label(self, s, o):
return self.emit(s, RDFS.label, Literal(o))
def emit_not(self, s, t):
bn = self.blanknode()
self.emit_type(bn, OWL.Class)
self.emit(bn, OWL.complementOf, URIRef(expand_uri(t)))
return self.emit_type(s, bn)
def eco_class(self, code, coderef=None):
eco_cls_id = self.ecomap.coderef_to_ecoclass(code, coderef)
logger.debug(self.ecomap._mappings)
logger.debug('ECO: {},{}->{}'.format(code, coderef, eco_cls_id))
return self.uri(eco_cls_id)
def translate_evidence(self, association, stmt):
"""
``
_:1 a Axiom
owl:annotatedSource s
owl:annotatedProperty p
owl:annotatedTarget o
evidence [ a ECO ; ...]
``
"""
ev = association['evidence']
ev_id = None
if 'id' in ev:
ev_id = self.uri(ev['id'])
else:
ev_id = genid(base=self.writer.base + '/')
stmt_id = self.blanknode() ## OWL reification: must be blank
(s, p, o) = stmt
self.emit_type(stmt_id, OWL.Axiom)
self.emit(stmt_id, OWL.annotatedSource, s)
self.emit(stmt_id, OWL.annotatedProperty, p)
self.emit(stmt_id, OWL.annotatedTarget, o)
self.emit(stmt_id, self.uri(evt.axiom_has_evidence), ev_id)
ev_cls = self.eco_class(self.uri(ev['type']))
self.emit_type(ev_id, OWL.NamedIndividual)
self.emit_type(ev_id, ev_cls)
if 'with_support_from' in ev:
for w in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(w))
for ref in ev['has_supporting_reference']:
o = self.uri(ref)
if ref == expand_uri(ref):
o = Literal(ref)
self.emit(ev_id, HAS_SUPPORTING_REFERENCE, o)
if 'with_support_from' in ev:
for ref in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(ref))
class RdfTransform(object):
"""
base class for all RDF generators
"""
def __init__(self, writer=None):
if writer is None:
writer = TurtleRdfWriter()
self.writer = writer
self.include_subject_info = False
self.ecomap = EcoMap()
self._emit_header_done = False
self.uribase = writer.base
self.ro = None
self.ecomap.mappings()
def blanknode(self):
return BNode()
def uri(self, id):
# allow either atoms or objects
if isinstance(id, dict):
return self.uri(id['id'])
logging.info("Expand: {}".format(id))
uri = curie_util.expand_uri(id, cmaps=[prefix_context])
if uri != id:
# If URI is different, then that means we found an curie expansion, and we should add the prefix
prefix = id.split(":")[0]
self.writer.graph.bind(prefix, prefix_context[prefix])
return URIRef(uri)
def get_relation_ontology(self):
if self.ro is None:
ofa = OntologyFactory()
self.ro = ofa.create('ro')
return self.ro
def lookup_relation(self, label):
ro = self.get_relation_ontology()
label = label.replace('_', ' ')
results = [self.uri(x) for x in ro.search(label)]
if len(results) > 0:
return results[0]
def emit(self, s, p, o):
logging.debug("TRIPLE: {} {} {}".format(s, p, o))
self.writer.add(s, p, o)
return (s, p, o)
def emit_type(self, s, t):
return self.emit(s, RDF.type, t)
def emit_label(self, s, t):
return self.emit(s, RDFS.label, o)
def eco_class(self, code, coderef=None):
eco_cls_id = self.ecomap.coderef_to_ecoclass(code, coderef)
logging.debug(self.ecomap._mappings)
logging.debug('ECO: {},{}->{}'.format(code, coderef, eco_cls_id))
return self.uri(eco_cls_id)
def translate_evidence(self, association, stmt):
"""
``
_:1 a Axiom
owl:annotatedSource s
owl:annotatedProperty p
owl:annotatedTarget o
evidence [ a ECO ; ...]
``
"""
ev = association['evidence']
ev_id = None
if 'id' in ev:
ev_id = self.uri(ev['id'])
else:
ev_id = genid(base=self.writer.base + '/')
stmt_id = self.blanknode() ## OWL reification: must be blank
(s, p, o) = stmt
self.emit_type(stmt_id, OWL.Axiom)
self.emit(stmt_id, OWL.annotatedSource, s)
self.emit(stmt_id, OWL.annotatedProperty, p)
self.emit(stmt_id, OWL.annotatedTarget, o)
self.emit(stmt_id, self.uri(evt.axiom_has_evidence), ev_id)
ev_cls = self.eco_class(self.uri(ev['type']))
self.emit_type(ev_id, OWL.NamedIndividual)
self.emit_type(ev_id, ev_cls)
if 'with_support_from' in ev:
for w in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(w))
for ref in ev['has_supporting_reference']:
o = self.uri(ref)
if ref == expand_uri(ref):
o = Literal(ref)
self.emit(ev_id, HAS_SUPPORTING_REFERENCE, o)
if 'with_support_from' in ev:
for ref in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(ref))
class RdfTransform(object):
"""
base class for all RDF generators
"""
def __init__(self, writer=None):
if writer is None:
writer = TurtleRdfWriter()
self.writer = writer
self.include_subject_info = False
self.ecomap = EcoMap()
self._emit_header_done = False
self.uribase = 'http://example.org/'
def genid(self):
return URIRef(uuid.uuid4().urn)
def blanknode(self):
return BNode()
def uri(self, id):
# allow either atoms or objects
if isinstance(id, dict):
return self.uri(id['id'])
logging.info("Expand: {}".format(id))
return URIRef(expand_uri(id))
def emit(self, s, p, o):
logging.debug("TRIPLE: {} {} {}".format(s, p, o))
self.writer.add(s, p, o)
return (s, p, o)
def emit_type(self, s, t):
return self.emit(s, RDF.type, t)
def emit_label(self, s, t):
return self.emit(s, RDFS.label, o)
def eco_class(self, code, coderef=None):
eco_cls_id = self.ecomap.coderef_to_ecoclass(code, coderef)
logging.debug(self.ecomap._mappings)
logging.debug('ECO: {},{}->{}'.format(code, coderef, eco_cls_id))
return self.uri(eco_cls_id)
def translate_evidence(self, association, stmt):
"""
``
_:1 a Axiom
subject s
predicate p
object o
evidence [ a ECO ; ...]
``
"""
ev = association['evidence']
ev_id = None
if 'id' in ev:
ev_id = self.uri(ev['id'])
else:
ev_id = self.genid()
stmt_id = self.blanknode() ## OWL reification: must be blank
(s, p, o) = stmt
self.emit_type(stmt_id, OWL.Axiom)
self.emit(stmt_id, OWL.subject, s)
self.emit(stmt_id, OWL.predicate, p)
self.emit(stmt_id, OWL.object, o)
self.emit(stmt_id, self.uri(evt.axiom_has_evidence), ev_id)
ev_cls = self.eco_class(self.uri(ev['type']))
self.emit_type(ev_id, OWL.NamedIndividual)
self.emit_type(ev_id, ev_cls)
if 'with_support_from' in ev:
for w in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(w))
for ref in ev['has_supporting_reference']:
self.emit(ev_id, HAS_SUPPORTING_REFERENCE, self.uri(ref))
if 'with_support_from' in ev:
for ref in ev['with_support_from']:
self.emit(ev_id, self.uri(evt.evidence_with_support_from),
self.uri(ref))
