Python RDFS.subClassOf方法代码示例

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def read_sub_class_of():
    sub_class_of = {}
    g = Graph()
    g.parse("dbpedia_2016-04.nt", format="nt")
    for s, o in g.subject_objects(RDFS.subClassOf):
        str_s = str(s)
        str_o = str(o)
        if str_s.startswith('http://dbpedia.org/ontology/') and str_o.startswith('http://dbpedia.org/ontology/'):
            sub_class_of[str_s] = str_o
    return sub_class_of 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def getSubClasses(self, cls):
        return self.ontology.transitive_subjects(RDFS.subClassOf, cls) 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def getSuperClasses(self, cls):
        return self.ontology.transitive_objects(cls, RDFS.subClassOf) 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def enrichOntology(self):
        graph = self.rich_ontology = GraphOverlay(self.ontology)
        self.addTransitiveClosure(graph, RDFS.subPropertyOf)
        self.addTransitiveClosure(graph, RDFS.subClassOf)
        self.addInstanceStatements(graph, RDFS.Class, RDFS.subClassOf)
        self.addInstanceStatements(graph, RDF.Property, RDFS.subPropertyOf)
        return graph 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def calc_inference(self, graph):
        first = changes = True
        while first or changes:
            if first or changes:
                # {?P @has owl:inverseOf ?I. ?S ?P ?O} => {?O ?I ?S}.
                changes = self.add_inverses(graph)
            if first or changes:
                # {?P @has rdfs:subPropertyOf ?R. ?S ?P ?O} => {?S ?R ?O}.
                # {?P @has owl:subPropertyOf ?R. ?S ?P ?O} => {?S ?R ?O}.
                changes = self.add_inheritance(graph, RDF.Property, RDFS.subPropertyOf)
            first = False
            # loop because inheritance could add inverses.
        # {?P @has rdfs:domain ?C. ?S ?P ?O} => {?S a ?C}.
        for (p, _, c) in self.ontology.triples((None, RDFS.domain, None)):
            rs = {s for (s, _, o) in graph.triples((None, p, None))}
            for r in rs:
                t = (r, RDF.type, c)
                if t not in graph:
                    graph.add(t)
        # {?P @has rdfs:range ?C. ?S ?P ?O} => {?O a ?C}.
        for (p, _, c) in self.ontology.triples((None, RDFS.range, None)):
            rs = {o for (s, _, o) in graph.triples((None, p, None))}
            for r in rs:
                t = (r, RDF.type, c)
                if t not in graph:
                    graph.add(t)
        self.add_inheritance(graph, RDFS.Class, RDFS.subClassOf) 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def getDirectSubClasses(self, cls):
        return self.base_ontology.subjects(RDFS.subClassOf, cls) 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import subClassOf [as 别名]
def rdfs2dot(g, stream, opts={}):
    """
    Convert the RDFS schema in a graph
    writes the dot output to the stream
    """

    fields = collections.defaultdict(set)
    nodes = {}

    def node(x):

        if x not in nodes:
            nodes[x] = "node%d" % len(nodes)
        return nodes[x]

    def label(x, g):

        l = g.value(x, RDFS.label)
        if l is None:
            try:
                l = g.namespace_manager.compute_qname(x)[2]
            except:
                pass  # bnodes and some weird URIs cannot be split
        return l

    stream.write(u"digraph { \n node [ fontname=\"DejaVu Sans\" ] ; \n")

    for x in g.subjects(RDF.type, RDFS.Class):
        n = node(x)

    for x, y in g.subject_objects(RDFS.subClassOf):
        x = node(x)
        y = node(y)
        stream.write(u"\t%s -> %s [ color=%s ] ;\n" % (y, x, ISACOLOR))

    for x in g.subjects(RDF.type, RDF.Property):
        for a, b in itertools.product(
                g.objects(x, RDFS.domain), g.objects(x, RDFS.range)):
            if b in XSDTERMS or b == RDFS.Literal:
                l = label(b, g)
                if b == RDFS.Literal:
                    l = "literal"
                fields[node(a)].add((label(x, g), l))
            else:
    #            if a in nodes and b in nodes:
                stream.write(
                    "\t%s -> %s [ color=%s, label=\"%s\" ];\n" % (
                        node(a), node(b), EDGECOLOR, label(x, g)))

    for u, n in nodes.items():
        stream.write(u"# %s %s\n" % (u, n))
        f = [u"<tr><td align='left'>%s</td><td>%s</td></tr>" %
             x for x in sorted(fields[n])]
        opstr = u"%s [ shape=none, color=%s label=< <table color='#666666'" + \
                u" cellborder=\"0\" cellspacing='0' border=\"1\"><tr>" + \
                u"<td colspan=\"2\" bgcolor='grey'><B>%s</B></td>" + \
                u"</tr>%s</table> > ] \n"
        stream.write(opstr % (n, NODECOLOR, label(u, g), u"".join(f)))

    stream.write("}\n")