Python RDFS.range方法代码示例

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import range [as 别名]
def get_sparql(self):
        """
        Formats the query proposal as part of a sparql where clause.
        :return: String representation as sparql where clause part.
        """
        result = []
        subj_name = "?s" if not self.single else self.entity
        try:
            lit_name = "?{}{}".format(self.property.rsplit("/", 1)[1], self.range.rsplit("XMLSchema#")[1].capitalize())
        except IndexError:
            lit_name = "?{}".format(self.property.rsplit("/", 1)[-1])
        if self.explicit_class:
            result.append({
                "subject": subj_name,
                "predicate": "a",
                "object": self.cls
            })
        result.append({
            "subject": subj_name,
            "predicate": self.property.toPython(),
            "object": lit_name
        })
        return result 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import range [as 别名]
def __init__(self, cls, property, range, single=False, entity=None):
        self.cls = cls
        self.explicit_class = not "genClass" in cls.toPython()
        self.single = single if single else False
        if self.single:
            self.entity = entity
        if not self.explicit_class:
            self.extractor = re.findall("_(.*)", self.cls.rsplit("genClass", 1)[-1])[0]
        self.property = property
        self.range = range 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import range [as 别名]
def format_for_indra(self, include_extractor=True):
        """
        Formats the query proposal for ranking with indra.
        :param include_extractor: Whether to include the source of the triple proposed.
        :return: String representation.
        """
        formatted_cls = self.cls.rsplit("/", 1)[-1]
        if not self.explicit_class:
            formatted_cls = formatted_cls.split("genClass")[-1].strip()
            if not include_extractor:
                formatted_cls = formatted_cls[1:].split("_")[-1]

        formatted_prop = self.property.rsplit("/", 1)[-1].strip()

        return to_space("{0} {1}".format(formatted_cls, formatted_prop))
    #
    # def __repr__(self):
    #     return repr(self.format_for_sparql())
    #
    # def format_for_sparql(self):
    #     """
    #     Formats the query proposal as sparql.
    #     :return: String representation as sparql where clause part.
    #     """
    #     result = []
    #     lit_name = "?{}".format(self.range.rsplit("XMLSchema#")[1])
    #     if self.explicit_class:
    #         result.append("?s a {}".format(self.cls))
    #     result.append("?s {prop} {lit}".format(prop=self.property, lit=lit_name))
    #     return result 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import range [as 别名]
def range(self):
        return rdflib.RDFS.Literal 

# 需要导入模块: from rdflib import RDFS [as 别名]
# 或者: from rdflib.RDFS import range [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 range [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")