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)
