def setUpClass(cls): cls.g = Graph() cls.c1 = Bag(cls.g, BNode()) cls.c2 = Bag(cls.g, BNode(), [Literal("1"), Literal("2"), Literal("3"), Literal("4")]) cls.c3 = Alt(cls.g, BNode(), [Literal("1"), Literal("2"), Literal("3"), Literal("4")]) cls.c4 = Seq(cls.g, BNode(), [Literal("1"), Literal("2"), Literal("3"), Literal("4")])
def _to_rdf_id(self, context, id_val): bid = self._get_bnodeid(id_val) if bid: return BNode(bid) else: uri = context.resolve(id_val) if not self.generalized_rdf and ':' not in uri: return None return URIRef(uri)
def to_rdf(self, g: Graph) -> BNode: """ _:x rdf:type owl:Class . _:x owl:unionOf T(SEQ CE1 ... CEn) . """ rval = BNode() g.add((rval, RDF.type, OWL.Class)) g.add((rval, OWL.unionOf, SEQ(g, self.classExpressions))) return rval
def to_rdf(self, g: Graph) -> BNode: """ _:x rdf:type owl:Restriction . _:x owl:onProperty T(OPE) . _:x owl:cardinality "n"^^xsd:nonNegativeInteger . """ rval = BNode() ... return rval
def test_pretty_broken_xmlliteral(self): # given: g = ConjunctiveGraph() g.add((BNode(), RDF.value, Literal(u'''<p ''', datatype=RDF.XMLLiteral))) # when: xmlrepr = g.serialize(format='pretty-xml') # then: assert u'''<rdf:value rdf:datatype="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"><p '''.encode( 'utf-8') in xmlrepr
def _nodeid_to_bnode(iri): #from string import digits iri = iri[9:] # strip off "nodeID://" bnode = iri if len(iri) == 17: # assume we made it... ones, tens = iri[1::2], iri[2::2] chars = [x + y for x, y in zip(ones, tens)] bnode = "".join(str(chr(int(x) + 38)) for x in chars) return BNode(bnode)
def to_rdf(self, g: Graph) -> None: if len(self.individuals) == 2: self.add_triple(g, self.individuals[0].to_rdf(g), OWL.differentFrom, self.individuals[1].to_rdf(g)) elif len(self.individuals) > 2: subj = BNode() g.add((subj, RDF.type, OWL.AllDifferent)) g.add((subj, OWL.memebers, SEQ(g, self.individuals))) self.TANN(g, subj) return None
def to_rdf(self, g: Graph, emit_type_arc: bool = False) -> None: if len(self.classExpressions) == 2: self.add_triple(g, self.classExpressions[0].to_rdf(g), OWL.disjointWith, self.classExpressions[1].to_rdf(g)) else: subj = BNode() g.add((subj, RDF.type, OWL.AllDisjointClasses)) g.add((subj, OWL.members, SEQ(g, self.classExpressions))) self.TANN(g, subj)
def transformList(node, link, components): here = node for cmp in components: child = BNode() shapesGraph.add((here, link, child)) this = transformComponent(cmp) shapesGraph.add((child, RDF.first, this)) link = RDF.rest here = child shapesGraph.add((here, link, RDF.nil))
def _to_object(state, term, node): graph, context, base = state if isinstance(node, dict) and context.list_key in node: node_list = node.get(context.list_key) if node_list: first_subj = BNode() l_subj, l_next = first_subj, None for l_node in node_list: if l_next: graph.add((l_subj, RDF.rest, l_next)) l_subj = l_next l_obj = _to_object(state, None, l_node) graph.add((l_subj, RDF.first, l_obj)) l_next = BNode() graph.add((l_subj, RDF.rest, RDF.nil)) return first_subj else: node = {context.id_key: unicode(RDF.nil)} if not isinstance(node, dict): if not term or not term.coercion: if isinstance(node, float): # TODO: JSON-LD promotes double over decimal; # verify correctness... return Literal(node, datatype=XSD.double) return Literal(node, lang=context.lang) else: if term.coercion == ID_KEY: node = {context.id_key: context.expand(node)} else: node = { context.type_key: term.coercion, context.literal_key: node } if context.lang_key in node: return Literal(node[context.literal_key], lang=node[context.lang_key]) elif context.type_key and context.literal_key in node: return Literal(node[context.literal_key], datatype=context.expand(node[context.type_key])) else: return _add_to_graph(state, node)
def transformShape(shape, node=None): if node is None: node = BNode() shapesGraph.add((node, RDF.type, SH.Shape)) if shape.get('filter') is not None: transformFilter(shape.filter, node) if shape.get('body') is not None: transformComponent(shape.body, node) else: transformComponent(shape, node) return node
def _add_to_graph(self, dataset, graph, context, node, topcontext=False): if not isinstance(node, dict) or context.get_value(node): return if CONTEXT in node and not topcontext: local_context = node[CONTEXT] if local_context: context = context.subcontext(local_context) else: context = Context(base=context.doc_base) context = context.get_context_for_type(node) id_val = context.get_id(node) if id_val is None: id_val = self._get_nested_id(context, node) if isinstance(id_val, str): subj = self._to_rdf_id(context, id_val) else: subj = BNode() if subj is None: return None # NOTE: crude way to signify that this node might represent a named graph no_id = id_val is None for key, obj in node.items(): if key == CONTEXT or key in context.get_keys(ID): continue if key == REV or key in context.get_keys(REV): for rkey, robj in obj.items(): self._key_to_graph( dataset, graph, context, subj, rkey, robj, reverse=True, no_id=no_id, ) else: self._key_to_graph(dataset, graph, context, subj, key, obj, no_id=no_id) return subj
def to_graph(self, graph=None, node=None, td_nodes=None, th_nodes=None, abstract=False, **kwargs): # type: (Graph, Node, dict, dict, bool, dict) -> Graph if node is None: node = self.node or BNode() if graph is None: graph = bound_graph(str(node)) if td_nodes is None: td_nodes = {td: td.node for td in self.tds} if th_nodes is None: th_nodes = {r: r.node for r in self.resources} graph.add((node, RDF.type, CORE.Ecosystem)) roots = self.roots for td in self.tds: if td in roots: graph.add( (node, CORE.hasComponent, td.resource.node if not th_nodes else th_nodes.get(td.resource.node, td.resource.node))) if not abstract: td_node = td_nodes.get(td, None) if td_nodes else None for ext in td.extends: ext.to_graph(graph=graph, node=ext.node, td_nodes=td_nodes, th_nodes=th_nodes, **kwargs) td.to_graph(graph=graph, node=td_node, td_nodes=td_nodes, th_nodes=th_nodes, **kwargs) for root in self.non_td_root_resources: graph.add((node, CORE.hasComponent, root.node)) g = root.to_graph(**kwargs) if not abstract: graph.__iadd__(g) else: for t in g.objects(root.node, RDF.type): graph.add((root.node, RDF.type, t)) for e in self.__enrichments: graph.add((node, CORE.implements, e.node)) if not abstract: e.to_graph(graph=graph, node=e.node, td_nodes=td_nodes) return graph
def _owl_obj_union_of_converter(ce: OWLObjectUnionOf) \ -> Tuple[Identifier, List[Tuple[Identifier, Identifier, Identifier]]]: union_res = BNode() seq_res, seq_triples = _seq_converter([o for o in ce.operands]) triples = seq_triples[:] triples.append((union_res, RDF.type, OWL.Class)) triples.append((union_res, OWL.unionOf, seq_res)) return union_res, triples
def to_rdf(self, g: Graph) -> BNode: subj = BNode() if self.dataPropertyExpression >= 2: g.add((subj, RDF.type, OWL.Restriction)) g.add((subj, OWL.onProperties, SEQ(g, self.dataPropertyExpression))) g.add((subj, OWL.allValuesFrom, self.dataRange.to_rdf(g))) else: g.add((subj, RDF.type, OWL.Restriction)) g.add((subj, OWL.onProperties, self.dataPropertyExpression)) g.add((subj, OWL.allValuesFrom, self.dataRange.to_rdf(g)))
def transform(dfns): for dfn in dfns: # print ("DEFINITION",dfn) if dfn.token == '@prefix': # print ("Namespace",dfn[1],"is",dfn[3]) nsm.bind(dfn[1], dfn[3], replace=True) else: n = BNode() if dfn.get('name') is None else toNode(dfn.get('name')) if dfn.get('scope') is not None: transformScope(dfn.get('scope'), n) transformShape(dfn.get('shape'), n)
def to_rdf(self, g: Graph) -> BNode: """ _:x rdf:type owl:Restriction . _:x owl:onProperty T(OPE) . _:x owl:hasValue T(a) . """ rval = BNode() g.add((rval, RDF.type, OWL.Restriction)) g.add((rval, OWL.onProperty, self.objectPropertyExpression.to_rdf(g))) g.add((rval, OWL.hasValue, self.individual.to_rdf(g))) return rval
def to_graph(self, subject, obj, fieldname, graph): uri = self.get_uri(obj) if self.opts.type: graph.add((uri, RDF.type, self.opts.type)) obj_to_add = [] if fieldname: field_value = getattr(obj, fieldname, None) if field_value: if self.many: obj_to_add = [(nested_obj, BNode()) for nested_obj in field_value.all()] else: obj_to_add = [(field_value, BNode())] else: obj_to_add = [(obj, uri)] for nested_obj, nested_uri in obj_to_add: self.object_to_graph(subject, nested_uri, nested_obj, graph)
def test_pretty_broken_xmlliteral(self): # given: g = ConjunctiveGraph() g.add((BNode(), RDF.value, Literal("""<p """, datatype=RDF.XMLLiteral))) # when: xmlrepr = g.serialize(format="pretty-xml") # then: assert ( """<rdf:value rdf:datatype="http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"><p """ .encode("utf-8") in xmlrepr)
def __init__(self, uri=None, types=None): # type: (any, iter) -> None self.__graph = bound_graph(identifier=uri) self.__node = uri if self.__node is None: self.__node = BNode() if types is None: types = [] self.__types = set(types) for t in self.__types: self.__graph.add((self.__node, RDF.type, URIRef(t)))
def to_rdf(self, g: Graph) -> BNode: """ _:x rdf:type owl:Class . _:x owl:oneOf T(SEQ a1 ... an) . :param g: :return: """ rval = BNode() g.add((rval, RDF.type, OWL.Class)) g.add((rval, OWL.oneOf, SEQ(g, self.individuals))) return rval
def node_to_ident(self, node): if node.type == BNODE_NODE_TYPE: return BNode(node.key) else: ns = self.namespace(node.type) if ns is None: ns = Namespace(self.namespace_base[node.type + "#"]) self.bind(node.type, ns) uri = ns[node.key] log.debug("Converted node %s to uri %s" % (node, uri)) return uri
def add_rule_in(graph): """ Helper function for defining N3 rules in a Graph. Usage:: g = Graph() wih add_rule_in(g) as (ifgraph, thengraph): ifgraph.add((...)) thengraph.add((...)) """ store = graph.store assert store.formula_aware ifgraph = QuotedGraph(store, BNode()) thengraph = QuotedGraph(store, BNode()) try: yield (ifgraph, thengraph) graph.add((ifgraph, LOG.implies, thengraph)) except: raise
def from_n3(s, default=None, backend=None): """ Creates the Identifier corresponding to the given n3 string. """ if not s: return default if s.startswith('<'): return URIRef(s[1:-1]) elif s.startswith('"'): # TODO: would a regex be faster? value, rest = s.rsplit('"', 1) value = value[1:] # strip leading quote if rest.startswith("@"): if "^^" in rest: language, rest = rest.rsplit('^^', 1) language = language[1:] # strip leading at sign else: language = rest[1:] # strip leading at sign rest = '' else: language = None if rest.startswith("^^"): datatype = rest[3:-1] else: datatype = None value = value.replace('\\"', '"').replace('\\\\', '\\') # Hack: this should correctly handle strings with either native unicode # characters, or \u1234 unicode escapes. value = value.encode("raw-unicode-escape").decode("unicode-escape") return Literal(value, language, datatype) elif s.startswith('{'): identifier = from_n3(s[1:-1]) return QuotedGraph(backend, identifier) elif s.startswith('['): identifier = from_n3(s[1:-1]) return Graph(backend, identifier) else: if s.startswith("_:"): return BNode(s[2:]) else: return BNode(s)
def __init__(self, store='default', identifier=None, namespace_manager=None): super(Graph, self).__init__() self.__identifier = identifier or BNode() if not isinstance(store, Store): # TODO: error handling self.__store = store = plugin.get(store, Store)() else: self.__store = store self.__namespace_manager = namespace_manager self.context_aware = False self.formula_aware = False
def cparen(prod, tok): items = self.lists.pop() if items: first = head = BNode() for (i, item) in enumerate(items): if i < len(items) - 1: rest = BNode() else: rest = RDF.nil self.triple(first, RDF.first, item) self.triple(first, RDF.rest, rest) first = rest else: head = RDF.nil self.mode.pop() if self.paths: self.paths[-1].append(head) elif self.mode and self.mode[-1] == 'list': self.lists[-1].append(head) else: self.triples[-1].append(head)
def _add_list(self, dataset, graph, context, term, node_list): if not isinstance(node_list, list): node_list = [node_list] first_subj = BNode() subj, rest = first_subj, None for node in node_list: if node is None: continue if rest: graph.add((subj, RDF.rest, rest)) subj = rest obj = self._to_object(dataset, graph, context, term, node, inlist=True) if obj is None: continue graph.add((subj, RDF.first, obj)) rest = BNode() if rest: graph.add((subj, RDF.rest, RDF.nil)) return first_subj else: return RDF.nil
def unRollCollection(collection, queryProlog): nestedComplexTerms = [] listStart = convertTerm(collection.identifier, queryProlog) if not collection._list: return yield (listStart, RDF.rest, RDF.nil) elif len(collection._list) == 1: singleItem = collection._list[0] if isinstance(singleItem, RDFTerm): nestedComplexTerms.append(singleItem) yield (listStart, RDF.first, convertTerm(singleItem.identifier, queryProlog)) else: yield (listStart, RDF.first, convertTerm(singleItem, queryProlog)) yield (listStart, RDF.rest, RDF.nil) else: singleItem = collection._list[0] if isinstance(singleItem, Identifier): singleItem = singleItem else: singleItem = singleItem.identifier yield (listStart, RDF.first, convertTerm(singleItem, queryProlog)) prevLink = listStart for colObj in collection._list[1:]: linkNode = convertTerm(BNode(), queryProlog) if isinstance(colObj, RDFTerm): nestedComplexTerms.append(colObj) yield (linkNode, RDF.first, convertTerm(colObj.identifier, queryProlog)) else: yield (linkNode, RDF.first, convertTerm(colObj, queryProlog)) yield (prevLink, RDF.rest, linkNode) prevLink = linkNode yield (prevLink, RDF.rest, RDF.nil) for additionalItem in nestedComplexTerms: for item in unRollRDFTerm(additionalItem, queryProlog): yield item
def term(str, default=None): """See also from_n3""" if not str: return default elif str.startswith("<") and str.endswith(">"): return URIRef(str[1:-1]) elif str.startswith('"') and str.endswith('"'): return Literal(str[1:-1]) elif str.startswith("_"): return BNode(str) else: msg = "Unknown Term Syntax: '%s'" % str raise Exception(msg)
def test_sparql_multiline_literal(self): lit_str = """foo bar""" triple1 = (BNode(), URIRef('http://www.google.com'), Literal(lit_str)) triple2 = (BNode(), URIRef('http://www.google.com'), Literal('foo')) triple3 = (BNode(), URIRef('http://www.google.com'), URIRef('http://foo.com')) self.rdflib_graph.add(triple1) self.rdflib_graph.add(triple2) self.rdflib_graph.add(triple3) self.rdflib_graph.commit() q = """ SELECT ?s ?p WHERE { ?s ?p \"""%s\""" . } """ % (lit_str, ) results = 0 for (s, p) in self.rdflib_graph.query(q): results += 1 self.assertTrue((s, p, Literal(lit_str)) == triple1) self.assertTrue(results == 1)