def __getTopProps(self, classPredicate='', includeImplicit=False):
"""
Finds the topclass in an ontology (works also with multiple inheritance)
"""
returnlist = []
searchspace = []
if classPredicate not in [
"", 'rdf.property', 'owl.objectproperty',
'owl.datatypeproperty', 'owl.annotationproperty'
]:
raise exceptions.Error(
"ClassPredicate must be blank or either 'rdf.property' or 'owl.objectproperty' or 'owl.datatypeproperty' or 'owl.annotationproperty'"
)
if classPredicate == "rdf.property" or classPredicate == "":
searchspace += self.allrdfproperties
if classPredicate == "owl.objectproperty" or classPredicate == "":
searchspace += self.allobjproperties
if classPredicate == "owl.datatypeproperty" or classPredicate == "":
searchspace += self.alldataproperties
if classPredicate == "owl.annotationproperty" or classPredicate == "":
searchspace += self.allannotationproperties
if includeImplicit:
searchspace += self.allinferredproperties
for eachprop in searchspace:
x = self.propertyDirectSupers(eachprop)
if not x:
returnlist.append(eachprop)
return sort_uri_list_by_name(returnlist)
def propertyFind(self, name, exact = False, classPredicate = "", includeImplicit=False):
"""
Find a property from its name (string representation of URI or part of it) within an ontology graph.
Returns a list that in the 'exact' case will have one element only
classPredicate: one of "rdf.property", "owl.objectproperty", "owl.datatypeproperty"
EG:
> onto.propertyFind("purl.org", classPredicate="owl.objectproperty")
"""
temp = []
searchspace = []
if classPredicate not in ["", 'rdf.property', 'owl.objectproperty','owl.datatypeproperty']:
raise exceptions.Error("ClassPredicate must be blank or either 'rdf.property' or 'owl.objectproperty' or 'owl.datatypeproperty'")
if classPredicate == "rdf.property" or classPredicate == "":
searchspace += self.allrdfproperties
if classPredicate == "owl.objectproperty" or classPredicate == "":
searchspace += self.allobjproperties
if classPredicate == "owl.datatypeproperty" or classPredicate == "":
searchspace += self.alldataproperties
if includeImplicit:
searchspace += self.allinferredproperties
if name:
for x in searchspace:
if exact:
if x.__str__().lower() == str(name).lower():
return [x]
else:
if x.__str__().lower().find(str(name).lower()) >= 0:
temp.append(x)
return temp
def instanceAddForClass(self, aClass, anInstance, ns = None):
"""
2011-07-26:
Adds or creates a class-instance to the session-graph (and returns the instance).
If a URIRef object is passed, that's ok. Also, if a string is passed, we create a URI using the
default namespace for the Session graph.
p.s. No need to check for duplicates: rdflib does that already!
"""
if aClass in self.allclasses:
if type(anInstance) == URIRef:
self.sessionGraph.add((anInstance, RDF.type, aClass))
return anInstance
elif type(anInstance) == type("string") or type(anInstance) == type(u"unicode"):
ns = ns or self.sessionNS # needed?
self.sessionGraph.add((ns[anInstance], RDF.type, aClass))
return ns[anInstance]
else:
raise exceptions.Error("Instance must be a URIRef object or a String")
else:
raise exceptions.Error("Class is not available in current ontology")
def __getAllProperties(self, classPredicate="", includeImplicit=False):
"""
Extracts all the properties declared in a model.
Args:
> classPredicate: a mapping to one of the allowed OWL props
> includeImplicit: gets all predicates from triples and infers that they are all RDF properties (even if not explicitly declared)
Corresponding RDF predicates:
OWL.ObjectProperty, OWL.DatatypeProperty, OWL.AnnotationProperty, RDF.Property
"""
rdfGraph = self.rdfGraph
exit = {}
if classPredicate not in [
"", 'rdf.property', 'owl.objectproperty',
'owl.datatypeproperty', 'owl.annotationproperty'
]:
raise exceptions.Error(
"ClassPredicate must be either 'rdf.property' or 'owl.objectproperty' or 'owl.datatypeproperty' or 'owl.annotationproperty' "
)
def addIfYouCan(x, mydict):
if x not in mydict:
mydict[x] = None
return mydict
if classPredicate == "rdf.property" or "":
for s in rdfGraph.subjects(RDF.type, RDF.Property):
exit = addIfYouCan(s, exit)
if includeImplicit:
# includes everything that appears as a predicate;
# below we add also owl properties due to inheritance: they are instances of of rdf:property subclasses
for s in rdfGraph.predicates(None, None):
exit = addIfYouCan(s, exit)
if classPredicate == "owl.objectproperty" or classPredicate == "" or includeImplicit:
for s in rdfGraph.subjects(RDF.type, OWL.ObjectProperty):
exit = addIfYouCan(s, exit)
if classPredicate == "owl.datatypeproperty" or classPredicate == "" or includeImplicit:
for s in rdfGraph.subjects(RDF.type, OWL.DatatypeProperty):
exit = addIfYouCan(s, exit)
if classPredicate == "owl.annotationproperty" or classPredicate == "" or includeImplicit:
for s in rdfGraph.subjects(RDF.type, OWL.AnnotationProperty):
exit = addIfYouCan(s, exit)
# get a list
exit = exit.keys()
return sort_uri_list_by_name(exit)
def __init__(self, uri, language=""):
super(Inspector, self).__init__()
self.rdfGraph = ConjunctiveGraph()
try:
self.rdfGraph.parse(uri, format="application/rdf+xml")
except:
try:
self.rdfGraph.parse(uri, format="n3")
except:
raise exceptions.Error("Could not parse the file! Is it a valid RDF/OWL ontology?")
finally:
self.baseURI = self.get_OntologyURI() or uri
self.allclasses = self.__getAllClasses(includeDomainRange=True, includeImplicit=True, removeBlankNodes=False, excludeRDF_OWL=False)
def classInstances(self, aClass, onlydirect = True):
"""
Gets all the (direct by default) instances of a class
"""
if aClass in self.allclasses:
returnlist = []
for s, v, o in self.rdfGraph.triples((None , RDF.type , aClass)):
returnlist.append(s)
if not onlydirect:
for sub in self.classAllSubs(aClass):
for s, v, o in self.rdfGraph.triples((None , RDF.type , sub)):
returnlist.append(s)
return sort_uri_list_by_name(remove_duplicates(returnlist))
else:
raise exceptions.Error("Class is not available in current ontology")
def __getAllClasses(self, classPredicate = "", removeBlankNodes = True):
"""
Extracts all the classes from a model
We use the RDFS and OWL predicate by default; also, we extract non explicitly declared classes
"""
rdfGraph = self.rdfGraph
exit = []
if not classPredicate:
for s, v, o in rdfGraph.triples((None, RDF.type , OWL.Class)):
exit.append(s)
for s, v, o in rdfGraph.triples((None, RDF.type , RDFS.Class)):
exit.append(s)
# this extra routine makes sure we include classes not declared explicitly
# eg when importing another onto and subclassing one of its classes...
for s, v, o in rdfGraph.triples((None, RDFS.subClassOf , None)):
if s not in exit:
exit.append(s)
if o not in exit:
exit.append(o)
# this extra routine includes classes found only in rdfs:domain and rdfs:range definitions
for s, v, o in rdfGraph.triples((None, RDFS.domain , None)):
if o not in exit:
exit.append(o)
for s, v, o in rdfGraph.triples((None, RDFS.range , None)):
if o not in exit:
exit.append(o)
else:
if classPredicate == "rdfs" or classPredicate == "rdf":
for s, v, o in rdfGraph.triples((None, RDF.type , RDFS.Class)):
exit.append(s)
elif classPredicate == "owl":
for s, v, o in rdfGraph.triples((None, RDF.type , OWL.Class)):
exit.append(s)
else:
raise exceptions.Error("ClassPredicate must be either rdf, rdfs or owl")
exit = remove_duplicates(exit)
if removeBlankNodes:
exit = [x for x in exit if not self.__isBlankNode(x)]
return sort_uri_list_by_name(exit)
def __init__(self, uri, language=""):
super(OntoInspector, self).__init__()
self.rdfGraph = ConjunctiveGraph()
try:
self.rdfGraph.parse(uri, format="xml")
except:
try:
self.rdfGraph.parse(uri, format="n3")
except:
raise exceptions.Error("Could not parse the file! Is it a valid RDF/OWL ontology?")
finally:
# let's cache some useful info for faster access
self.baseURI = self.get_OntologyURI() or uri
self.allclasses = self.__getAllClasses(classPredicate)
self.toplayer = self.__getTopclasses()
self.tree = self.__getTree()
def setSessionGraphNamespace(self, ns):
if ns.startswith("http://"):
self.sessionNS = ns
else:
raise exceptions.Error(
"Please provide a URI starting with 'http://'..")
