from ontobio.io import assocparser
from ontobio.io.gpadparser import GpadParser
from ontobio.io import gafparser
from ontobio.io.gafparser import GafParser
from ontobio.io import GafWriter
from ontobio.io.assocwriter import GpadWriter
from ontobio.assoc_factory import AssociationSetFactory
from ontobio.ontol_factory import OntologyFactory
from ontobio.model import association
from ontobio.rdfgen import relations
from ontobio.ecomap import EcoMap
ecomap = EcoMap()
ecomap.mappings()
import tempfile
import logging
import pytest
import io
import json
POMBASE = "tests/resources/truncated-pombase.gaf"
POMBASE_GPAD = "tests/resources/truncated-pombase.gpad"
ONT = "tests/resources/go-truncated-pombase.json"
QGAF = "tests/resources/test-qualifiers.gaf"
def test_skim_gaf():
p = GafParser()
p.config.ecomap = EcoMap()
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))
