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))