def create_ontology(identifier): ontology_uri = d1[identifier] o_ns = Namespace(ontology_uri+"#") r = requests.get(ontology_uri) xml = r.text.encode('utf-8') eml = ET.fromstring(xml) g = Graph() g.bind("rdfs", RDFS) g.bind("owl", OWL) ontology = infixowl.Ontology(ontology_uri, graph=g) datasetTitle = eml.find('dataset/title') if datasetTitle is not None: ontology.label = Literal(datasetTitle.text.strip()) ontology.comment = Literal('\n'.join([x.text for x in eml.findall('dataset/abstract/para') if x is not None and x.text is not None]).strip()) # Data Table: i = 0 for datatable in eml.findall("dataset/dataTable"): i += 1 entity_ident = str(i) entity = infixowl.Class(o_ns['_'.join(['d',entity_ident])],graph=g) entity.subClassOf = [oboe.Entity] entityLabel = [] for e in ['entityName','entityDescription']: if datatable.find(e) is not None and datatable.find(e).text is not None: entityLabel.append(datatable.find(e).text.strip()) entity.label = Literal(' '.join(entityLabel)) if datatable.find('entityDescription') is not None and datatable.find('entityDescription').text is not None: entity.comment = Literal(datatable.find('entityDescription').text.strip()) j = 0 for attribute in datatable.findall('attributeList/attribute'): j +=1 attribute_ident = str(j) characteristic = infixowl.Class(o_ns['_'.join(['d',entity_ident,'c',attribute_ident])],graph=g) characteristic.subClassOf = [oboe.Characteristic] label = [] for e in ['.//attributeName','.//attributeLabel','.//attributeDefinition']: if attribute.find(e) is not None and attribute.find(e).text is not None: label.append(attribute.find(e).text.strip()) characteristic.label = Literal(' '.join(label)) if attribute.find('.//attributeDefinition') is not None and attribute.find('.//attributeDefinition').text is not None: characteristic.comment = Literal(datatable.find('.//attributeDefinition').text.strip()) measurement_type = infixowl.Class(o_ns['_'.join(['d',entity_ident,'a',attribute_ident])],graph=g) g.add((measurement_type.identifier, urn.entityId, Literal(entity_ident))) g.add((measurement_type.identifier, urn.attributeId, Literal(attribute_ident))) measurement_type.label = Literal(g.value(entity.identifier,RDFS.label, default="") + " " + g.value(characteristic.identifier,RDFS.label, default="")) measurement_type.comment = Literal(g.value(entity.identifier,RDFS.comment, default="") + " " + g.value(characteristic.identifier,RDFS.comment, default="")) measurement_type.subClassOf = [ oboe.MeasurementType, infixowl.Restriction(oboe.measuresEntity, graph=g, someValuesFrom=entity), infixowl.Restriction(oboe.measuresCharacteristic, graph=g, someValuesFrom=characteristic) ] return g
def create_ontology(identifier): ontology_uri = d1[identifier] o_ns = Namespace(ontology_uri + "#") r = requests.get(ontology_uri) xml = r.text.encode('utf-8') eml = ET.fromstring(xml) g = Graph() g.bind("rdfs", RDFS) g.bind("owl", OWL) ontology = infixowl.Ontology(ontology_uri, graph=g) ontology.label = Literal(eml.find('dataset/title').text.strip()) ontology.comment = Literal('\n'.join( [x.text for x in eml.find('dataset/abstract/para')]).strip()) # Data Table: for datatable in eml.findall("dataset/dataTable"): entity_ident = datatable.attrib['id'] entity = infixowl.Class(o_ns[entity_ident], graph=g) entity.subClassOf = [oboe.Entity] entity.label = Literal(datatable.find('entityName').text.strip()) entity.comment = Literal( datatable.find('entityDescription').text.strip()) for attribute in datatable.findall('attributeList/attribute'): attribute_ident = attribute.attrib['id'] characteristic = infixowl.Class(o_ns[attribute_ident], graph=g) characteristic.subClassOf = [oboe.Characteristic] characteristic.label = Literal( datatable.find('.//attributeLabel').text.strip()) characteristic.comment = Literal( datatable.find('.//attributeDefinition').text.strip()) measurement_type = infixowl.Class(o_ns[entity_ident + "_" + attribute_ident], graph=g) measurement_type.label = Literal( g.label(entity.identifier) + " " + g.label(characteristic.identifier)) measurement_type.subClassOf = [ oboe.MeasurementType, infixowl.Restriction(oboe.measuresEntity, graph=g, someValuesFrom=entity), infixowl.Restriction(oboe.measuresCharacteristic, graph=g, someValuesFrom=characteristic) ] return g
def add_hierarchy(self, parent, edge, child): """ Helper function to simplify the addition of part_of style objectProperties to graphs. FIXME make a method of makeGraph? """ if type(parent) != rdflib.URIRef: parent = self.check_thing(parent) if type(edge) != rdflib.URIRef: edge = self.check_thing(edge) if type(child) != infixowl.Class: if type(child) != rdflib.URIRef: child = self.check_thing(child) child = infixowl.Class(child, graph=self.g) restriction = infixowl.Restriction(edge, graph=self.g, someValuesFrom=parent) child.subClassOf = [restriction] + [c for c in child.subClassOf]
def make_defined(graph, ilx_start, label, phenotype_id, restriction_edge, parent=None): ilx_start += 1 id_ = ilx_base.format(ilx_start) id_ = graph.expand(id_) restriction = infixowl.Restriction(graph.expand(restriction_edge), graph=graph.g, someValuesFrom=phenotype_id) defined = infixowl.Class(id_, graph=graph.g) defined.label = rdflib.Literal(label + ' neuron') intersection = infixowl.BooleanClass(members=(graph.expand(NIFCELL_NEURON), restriction), graph=graph.g) #intersection = infixowl.BooleanClass(members=(restriction,), graph=self.graph.g) defined.equivalentClass = [intersection] if parent is not None: defined.subClassOf = [graph.expand(parent)] return ilx_start
def clean_hbp_cell(): #old graph g = rdflib.Graph() if __name__ == '__main__': embed() path = Path(devconfig.git_local_base, 'methodsOntology/ttl/hbp_cell_ontology.ttl') if not path.exists(): raise devconfig.MissingRepoError(f'repo for {path} does not exist') g.parse(path.as_posix(), format='turtle') g.remove((None, rdflib.OWL.imports, None)) g.remove((None, rdflib.RDF.type, rdflib.OWL.Ontology)) #new graph NAME = 'NIF-Neuron-HBP-cell-import' mg = makeGraph(NAME, prefixes=PREFIXES) ontid = 'http://ontology.neuinfo.org/NIF/ttl/generated/' + NAME + '.ttl' mg.add_trip(ontid, rdflib.RDF.type, rdflib.OWL.Ontology) mg.add_trip(ontid, rdflib.RDFS.label, 'NIF Neuron HBP cell import') mg.add_trip(ontid, rdflib.RDFS.comment, 'this file was automatically using pyontutils/hbp_cells.py') mg.add_trip(ontid, rdflib.OWL.versionInfo, date.isoformat(date.today())) newgraph = mg.g skip = { '0000000':'SAO:1813327414', # cell #'0000001':NEURON, # neuron (equiv) #'0000002':'SAO:313023570', # glia (equiv) #'0000021':'NLXNEURNT:090804', # glut (equiv, but phen) #'0000022':'NLXNEURNT:090803', # gaba (equiv, but phen) '0000003':NEURON, '0000004':NEURON, '0000005':NEURON, '0000006':NEURON, '0000007':NEURON, '0000008':NEURON, '0000009':NEURON, '0000010':NEURON, '0000019':NEURON, '0000020':NEURON, '0000033':NEURON, '0000034':NEURON, '0000070':NEURON, '0000071':NEURON, } to_phenotype = { '0000021':('ilx:hasExpressionPhenotype', 'SAO:1744435799'), # glut, all classes that might be here are equived out '0000022':('ilx:hasExperssionPhenotype', 'SAO:229636300'), # gaba } lookup = {'NIFCELL', 'NIFNEURNT'} missing_supers = { 'HBP_CELL:0000136', 'HBP_CELL:0000137', 'HBP_CELL:0000140', } replace = set() phen = set() equiv = {} for triple in sorted(g.triples((None, None, None))): id_suffix = newgraph.namespace_manager.compute_qname(triple[0].toPython())[2] try: obj_suffix = newgraph.namespace_manager.compute_qname(triple[2].toPython())[2] except: # it wasn't a url pass # equiv insert for help if triple[1] == rdflib.OWL.equivalentClass and id_suffix not in skip and id_suffix not in to_phenotype: qnt = newgraph.namespace_manager.compute_qname(triple[2].toPython()) #print(qnt) if qnt[0] in lookup: try: lab = v.findById(qnt[0] + ':' + qnt[2])['labels'][0] print('REMOTE', qnt[0] + ':' + qnt[2], lab) #mg.add_trip(triple[2], rdflib.RDFS.label, lab) #mg.add_trip(triple[0], PREFIXES['NIFRID'] + 'synonym', lab) # so we can see it except TypeError: if qnt[2].startswith('nlx'): triple = (triple[0], triple[1], expand('NIFSTD:' + qnt[2])) #print('bad identifier') #check for equiv if triple[0] not in equiv: eq = [o for o in g.objects(triple[0], rdflib.OWL.equivalentClass)] if eq and id_suffix not in skip and id_suffix not in to_phenotype: if len(eq) > 1: print(eq) equiv[triple[0]] = eq[0] continue elif triple[0] in equiv: continue # edge replace if triple[1].toPython() == 'http://www.FIXME.org/nsupper#synonym': edge = mg.expand('NIFRID:abbrev') elif triple[1].toPython() == 'http://www.FIXME.org/nsupper#definition': edge = rdflib.namespace.SKOS.definition else: edge = triple[1] # skip or to phenotype or equiv if id_suffix in skip: # have to make a manual edit to rdflib to include 'Nd' in allowed 1st chars replace.add(triple[0]) #print('MEEP MEEP') elif id_suffix in to_phenotype: # have to make a manual edit to rdflib to include 'Nd' in allowed 1st chars phen.add(triple[0]) elif triple[1] == rdflib.RDFS.label: # fix labels if not triple[2].startswith('Hippocampus'): new_label = rdflib.Literal('Neocortex ' + triple[2], lang='en') newgraph.add((triple[0], edge, new_label)) else: newgraph.add((triple[0], edge, triple[2])) elif triple[2] in replace: mg.add_trip(triple[0], edge, skip[obj_suffix]) elif triple[2] in phen: edge_, rst_on = to_phenotype[obj_suffix] edge_ = expand(edge_) rst_on = expand(rst_on) this = triple[0] this = infixowl.Class(this, graph=newgraph) this.subClassOf = [expand(NEURON)] + [c for c in this.subClassOf] restriction = infixowl.Restriction(edge_, graph=newgraph, someValuesFrom=rst_on) this.subClassOf = [restriction] + [c for c in this.subClassOf] elif triple[2] in equiv: newgraph.add((triple[0], edge, equiv[triple[2]])) else: newgraph.add((triple[0], edge, triple[2])) # final cleanup for forward references (since we iterate through sorted) tt = rdflib.URIRef(expand('HBP_CELL:0000033')) tf = rdflib.URIRef(expand('HBP_CELL:0000034')) newgraph.remove((None, None, tt)) newgraph.remove((None, None, tf)) # add missing subClasses for nosub in missing_supers: mg.add_trip(nosub, rdflib.RDFS.subClassOf, NEURON) # cleanup for subClassOf for subject in sorted(newgraph.subjects(rdflib.RDFS.subClassOf, expand(NEURON))): sco = [a for a in newgraph.triples((subject, rdflib.RDFS.subClassOf, None))] #print('U WOT M8') if len(sco) > 1: #print('#############\n', sco) for s, p, o in sco: if 'hbp_cell_ontology' in o or 'NIF-Cell' in o and o != expand(NEURON): #or 'sao2128417084' in o: # neocortex pyramidal cell #print(sco) newgraph.remove((subject, rdflib.RDFS.subClassOf, expand(NEURON))) break # do ilx ilx_start = ilx_get_start() #ilx_conv_mem = memoize('hbp_cell_interlex.json')(ilx_conv) # FIXME NOPE, also need to modify the graph :/ ilx_labels, ilx_replace = ilx_conv(graph=newgraph, prefix='HBP_CELL', ilx_start=ilx_start) ilx_add_ids(ilx_labels) replace_map = ilx_replace for hbp, rep in skip.items(): ori = 'HBP_CELL:'+hbp if ori in replace_map: raise KeyError('identifier already in!??! %s' % ori) replace_map[ori] = rep for hbp, (e, rep) in to_phenotype.items(): ori = 'HBP_CELL:'+hbp if ori in replace_map: raise KeyError('identifier already in!??! %s' % ori) replace_map[ori] = edge, rep for hbp_iri, rep_iri in equiv.items(): hbp = newgraph.compute_qname(hbp_iri)[2] rep = newgraph.qname(rep_iri) ori = 'HBP_CELL:'+hbp if ori in replace_map: raise KeyError('identifier already in!??! %s' % ori) replace_map[ori] = rep return mg, replace_map
def make_neurons(syn_mappings, pedges, ilx_start_, defined_graph): ilx_start = ilx_start_ cheating = { 'vasoactive intestinal peptide': 'VIP', 'star': None, # is a morphological phen that is missing but hits scigraph } ng = makeGraph('NIF-Neuron', prefixes=PREFIXES) #""" It seemed like a good idea at the time... nif_cell = '~/git/NIF-Ontology/ttl/NIF-Cell.ttl' # need to be on neurons branch cg = rdflib.Graph() cg.parse(os.path.expanduser(nif_cell), format='turtle') missing = ( 'NIFCELL:nifext_55', 'NIFCELL:nifext_56', 'NIFCELL:nifext_57', 'NIFCELL:nifext_59', 'NIFCELL:nifext_81', 'NIFCELL:nlx_cell_091205', NIFCELL_NEURON, 'NIFCELL:sao2128417084', 'NIFCELL:sao862606388', # secondary, not explicitly in the hbp import ) for m in missing: m = ng.expand(m) for s, p, o in cg.triples((m, None, None)): ng.add_trip(s, p, o) #cg.remove((None, rdflib.OWL.imports, None)) # DONOTWANT NIF-Cell imports #for t in cg.triples((None, None, None)): #ng.add_trip(*t) # only way to clean prefixes :/ #cg = None #""" hbp_cell = '~/git/NIF-Ontology/ttl/generated/NIF-Neuron-HBP-cell-import.ttl' # need to be on neurons branch _temp = rdflib.Graph() # use a temp to strip nasty namespaces _temp.parse(os.path.expanduser(hbp_cell), format='turtle') for s, p, o in _temp.triples((None, None, None)): if s != rdflib.URIRef( 'http://ontology.neuinfo.org/NIF/ttl/generated/NIF-Neuron-HBP-cell-import.ttl' ): ng.g.add((s, p, o)) base = 'http://ontology.neuinfo.org/NIF/ttl/' ontid = base + ng.name + '.ttl' ng.add_trip(ontid, rdflib.RDF.type, rdflib.OWL.Ontology) ng.add_trip(ontid, rdflib.OWL.imports, base + 'NIF-Neuron-Phenotype.ttl') ng.add_trip(ontid, rdflib.OWL.imports, base + 'NIF-Neuron-Defined.ttl') ng.add_trip(ontid, rdflib.OWL.imports, base + 'hbp-special.ttl') #ng.add_trip(ontid, rdflib.OWL.imports, base + 'NIF-Cell.ttl') # NO! #ng.add_trip(ontid, rdflib.OWL.imports, base + 'external/uberon.owl') #ng.add_trip(ontid, rdflib.OWL.imports, base + 'external/pr.owl') ng.replace_uriref('ilx:hasMolecularPhenotype', 'ilx:hasExpressionPhenotype') #defined_graph = makeGraph('NIF-Neuron-Defined', prefixes=PREFIXES, graph=_g) defined_graph.add_trip(base + defined_graph.name + '.ttl', rdflib.RDF.type, rdflib.OWL.Ontology) defined_graph.add_trip(base + defined_graph.name + '.ttl', rdflib.OWL.imports, base + 'NIF-Neuron-Phenotype.ttl') done = True #False done_ = set() for pedge in pedges: for s, p, o_lit in ng.g.triples((None, pedge, None)): o = o_lit.toPython() success = False true_o = None true_id = None if o in syn_mappings: id_ = syn_mappings[o] ng.add_hierarchy(id_, p, s) ng.g.remove((s, p, o_lit)) #print('SUCCESS, substituting', o, 'for', id_) success = True true_o = o_lit true_id = id_ elif 'Location' in p.toPython() or 'LocatedIn' in p.toPython( ): # lift location to restrictions if o.startswith('http://'): ng.add_hierarchy(o_lit, p, s) ng.g.remove((s, p, o_lit)) data = sgv.findById(o) label = data['labels'][0] ng.add_trip(o, rdflib.RDF.type, rdflib.OWL.Class) ng.add_trip(o, rdflib.RDFS.label, label) success = True true_o = label true_id = o_lit else: if o in cheating: o = cheating[o] data = sgv.findByTerm(o) if data: print('SCIGRAPH', [(d['curie'], d['labels']) for d in data]) for d in data: if 'PR:' in d['curie']: sgt = ng.expand(d['curie']) ng.add_hierarchy(sgt, p, s) ng.g.remove((s, p, o_lit)) label = d['labels'][0] ng.add_trip(sgt, rdflib.RDF.type, rdflib.OWL.Class) ng.add_trip(sgt, rdflib.RDFS.label, label) success = True true_o = label true_id = sgt break if not success: for d in data: if 'NIFMOL:' in d['curie']: sgt = ng.expand(d['curie']) ng.add_hierarchy(sgt, p, s) ng.g.remove((s, p, o_lit)) label = d['labels'][0] ng.add_trip(sgt, rdflib.RDF.type, rdflib.OWL.Class) ng.add_trip(sgt, rdflib.RDFS.label, label) success = True true_o = label true_id = sgt break if o not in done_ and success: done_.add(o) t = tuple( defined_graph.g.triples( (None, rdflib.OWL.someValuesFrom, true_id))) if t: print('ALREADY IN', t) else: ilx_start += 1 id_ = ng.expand(ilx_base.format(ilx_start)) defined_graph.add_trip(id_, rdflib.RDF.type, rdflib.OWL.Class) restriction = infixowl.Restriction(p, graph=defined_graph.g, someValuesFrom=true_id) intersection = infixowl.BooleanClass( members=(defined_graph.expand(NIFCELL_NEURON), restriction), graph=defined_graph.g) this = infixowl.Class(id_, graph=defined_graph.g) this.equivalentClass = [intersection] this.subClassOf = [ defined_graph.expand(defined_class_parent) ] this.label = rdflib.Literal(true_o + ' neuron') print('make_neurons ilx_start', ilx_start, list(this.label)[0]) if not done: embed() done = True defined_graph.add_class(defined_class_parent, NIFCELL_NEURON, label='defined class neuron') defined_graph.add_trip(defined_class_parent, rdflib.namespace.SKOS.definition, 'Parent class For all defined class neurons') defined_graph.write() ng.write() for sub, syn in [ _ for _ in ng.g.subject_objects(ng.expand('NIFRID:synonym')) ] + [_ for _ in ng.g.subject_objects(rdflib.RDFS.label)]: syn = syn.toPython() if syn in syn_mappings: print('ERROR duplicate synonym!', syn, sub) syn_mappings[syn] = sub return ilx_start
def _row_post(self): # defined class lookup = { graph.expand('ilx:AxonPhenotype'): rdflib.URIRef('http://axon.org'), graph.expand('ilx:AxonMorphologicalPhenotype'): None, graph.expand('ilx:DendritePhenotype'): rdflib.URIRef('http://dendrite.org'), graph.expand('ilx:DendriteMorphologicalPhenotype'): None, graph.expand('ilx:SomaPhenotype'): rdflib.URIRef('http://soma.org'), graph.expand('ilx:SomaMorphologicalPhenotype'): None, graph.expand('ilx:NeuronPhenotype'): graph.expand(NIFCELL_NEURON), graph.expand('ilx:CellPhenotype'): None, graph.expand('ilx:Phenotype'): graph.expand('ilx:Phenotype'), } if self.id_ in lookup: return #elif 'Petilla' in self.id_: #return #else: #print(self.id_) # hidden label for consturctions graph2.add_trip(self.id_, rdflib.namespace.SKOS.hiddenLabel, self._label.rsplit(' Phenotype')[0]) self.ilx_start += 1 id_ = defined_graph.expand(ilx_base.format(self.ilx_start)) defined = infixowl.Class(id_, graph=defined_graph.g) #defined.label = rdflib.Literal(self._label.rstrip(' Phenotype') + ' neuron') # the extra space in rstrip removes 'et ' as well WTF! defined.label = rdflib.Literal( self._label.rstrip('Phenotype') + 'neuron') #print(self._label) print('_row_post ilx_start', self.ilx_start, list(defined.label)[0]) def getPhenotypeEdge(phenotype): print(phenotype) edge = 'ilx:hasPhenotype' # TODO in neuronManager... return edge edge = getPhenotypeEdge(self.id_) restriction = infixowl.Restriction(graph.expand(edge), graph=defined_graph.g, someValuesFrom=self.id_) parent = [p for p in self.child_parent_map[self.id_] if p] if parent: parent = parent[0] while 1: if parent == defined_graph.expand('ilx:NeuronPhenotype'): #defined.subClassOf = [graph.expand(defined_class_parent)] # XXX this does not produce what we want break #else: #print(parent, graph.expand('ilx:NeuronPhenotype')) #print('xxxxxxxxxxxxxxxx', parent) new_parent = [ p for p in self.child_parent_map[parent] if p ] if new_parent: parent = new_parent[0] else: break phenotype_equiv = lookup[parent] else: return intersection = infixowl.BooleanClass(members=(phenotype_equiv, restriction), graph=defined_graph.g) ##intersection = infixowl.BooleanClass(members=(restriction,), graph=self.graph.g) defined.equivalentClass = [intersection]
def make_table1(syn_mappings, ilx_start, phenotypes): # TODO when to explicitly subClassOf? I think we want this when the higher level phenotype bag is shared # it may turn out that things like the disjointness exist at a higher level while correlated properties # should be instantiated together as sub classes, for example if cck and # FIXME disagreement about nest basket cells # TODO hasPhenotypes needs to be function to get phenotypeOf to work via reasoner??? this seems wrong. # this also works if phenotypeOf is inverseFunctional # hasPhenotype shall be asymmetric, irreflexive, and intransitive # XXX in answer to Maryann's question about why we need the morphological phenotypes by themselves: # if we don't have them we can't agregate across orthogonal phenotypes since owl correctly keeps the classes distinct # TODO disjointness axioms work really well on defined classes and propagate excellently # TODO add 'Petilla' or something like that to the phenotype definitions # we want this because 'Petilla' denotes the exact ANALYSIS used to determine the phenotype # there are some additional 'protocol' related restrictions on what you can apply analysis to # but we don't have to model those explicitly which would be a nightmare and break the # orthogonality of the cell type decomposition # TODO to make this explicit we need to include that phenotypes require 2 things # 1) a type of data (data type?) 2) a way to classify that data (analysis protocol) # # need a full type restriction... property chain? graph = makeGraph('hbp-special', prefixes=PREFIXES) # XXX fix all prefixes with open(refile(__file__, 'resources/26451489 table 1.csv'), 'rt') as f: rows = [list(r) for r in zip(*csv.reader(f))] base = 'http://ontology.neuinfo.org/NIF/ttl/' ontid = base + graph.name + '.ttl' graph.add_trip(ontid, rdflib.RDF.type, rdflib.OWL.Ontology) graph.add_trip(ontid, rdflib.OWL.imports, base + 'NIF-Neuron-Phenotype.ttl') graph.add_trip(ontid, rdflib.OWL.imports, base + 'NIF-Neuron-Defined.ttl') def lsn(word): syn_mappings[word] = graph.expand( sgv.findByTerm(word)[0]['curie']) # cheating lsn('Parvalbumin') lsn('neuropeptide Y') lsn('VIP peptides') lsn('somatostatin') syn_mappings['calbindin'] = graph.expand('PR:000004967') # cheating syn_mappings['calretinin'] = graph.expand('PR:000004968') # cheating t = table1(graph, rows, syn_mappings, ilx_start) ilx_start = t.ilx_start # adding fake mouse data #with open(refile(__file__, 'resources/26451489 table 1.csv'), 'rt') as f: # FIXME annoying #rows = [list(r) for r in zip(*csv.reader(f))] #t2 = table1(graph, rows, syn_mappings, ilx_start, species='NCBITaxon:10090') # FIXME double SOM+ phenos etc #ilx_start = t2.ilx_start def do_graph(d): sgt = graph.expand(d['curie']) label = d['labels'][0] graph.add_trip(sgt, rdflib.RDF.type, rdflib.OWL.Class) graph.add_trip(sgt, rdflib.RDFS.label, label) done = set() for s, p, o in graph.g.triples( (None, None, None)): #(rdflib.RDFS.subClassOf,rdflib.OWL.Thing)): if o not in done and type(o) == rdflib.term.URIRef: done.add(o) if not [_ for _ in graph.g.objects((o, rdflib.RDFS.label))]: d = sgv.findById(o) if d: if 'PR:' in d['curie']: do_graph(d) elif 'NIFMOL:' in d['curie']: do_graph(d) elif 'UBERON:' in d['curie']: do_graph(d) elif 'NCBITaxon:' in d['curie']: do_graph(d) elif 'NIFCELL:' in d['curie']: do_graph(d) # FIXME this is a dupe with defined_class #graph.add_trip(defined_class_parent, rdflib.RDF.type, rdflib.OWL.Class) #graph.add_trip(defined_class_parent, rdflib.RDFS.label, 'defined class neuron') #graph.add_trip(defined_class_parent, rdflib.namespace.SKOS.description, 'Parent class For all defined class neurons') #graph.add_trip(defined_class_parent, rdflib.RDFS.subClassOf, NIFCELL_NEURON) #graph.add_trip(morpho_defined, rdflib.RDFS.subClassOf, defined_class_parent) #graph.add_trip(morpho_defined, rdflib.RDFS.label, 'Morphologically classified neuron') # FIXME -- need asserted in here... #graph.add_trip(ephys_defined, rdflib.RDFS.subClassOf, defined_class_parent) #graph.add_trip(ephys_defined, rdflib.RDFS.label, 'Electrophysiologically classified neuron') graph.add_class(expression_defined, NIFCELL_NEURON, autogen=True) graph.add_class('ilx:NeuroTypeClass', NIFCELL_NEURON, label='Neuron TypeClass') graph.g.commit() phenotype_dju_dict = add_types(graph, phenotypes) for pheno, disjoints in phenotype_dju_dict.items(): name = ' '.join(re.findall( r'[A-Z][a-z]*', pheno.split(':')[1])[:-1]) #-1: drops Phenotype ilx_start += 1 # = make_defined(graph, ilx_start, name + ' neuron type', pheno, 'ilx:hasPhenotype') id_ = graph.expand(ilx_base.format(ilx_start)) typeclass = infixowl.Class(id_, graph=graph.g) typeclass.label = rdflib.Literal(name + ' neuron type') restriction = infixowl.Restriction(graph.expand('ilx:hasPhenotype'), graph=graph.g, someValuesFrom=pheno) #typeclass.subClassOf = [restriction, graph.expand('ilx:NeuroTypeClass')] ntc = graph.expand('ilx:NeuroTypeClass') intersection = infixowl.BooleanClass(members=(ntc, restriction), graph=graph.g) typeclass.equivalentClass = [intersection] # FIXME not clear that we should be doing typeclasses this way.... :/ # requires more thought, on the plus side you do get better reasoning... disjointunion = disjointUnionOf(graph=graph.g, members=list(disjoints)) graph.add_trip(id_, rdflib.OWL.disjointUnionOf, disjointunion) graph.write() return t
def _graphify(self, graph=None): if graph is None: graph = self.out_graph return infixowl.Restriction(onProperty=self.e, someValuesFrom=self.p, graph=graph)