def parse(self, source, content_type):
res = Result('CONSTRUCT') # hmm - or describe?type_)
res.graph = Graph()
res.graph.parse(source, format=content_type)
return res
def parse(self, source):
if isinstance(source.read(0), bytestype):
# if reading from source returns bytes do utf-8 decoding
source = codecs.getreader('utf-8')(source)
try:
r = Result('SELECT')
header = source.readline()
r.vars = list(HEADER.parseString(header.strip(), parseAll=True))
r.bindings = []
while True:
line = source.readline()
if not line:
break
line = line.strip('\n')
if line == "":
continue
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(list(zip(r.vars, (self.convertTerm(x) for x in row)))))
return r
except ParseException as err:
print(err.line)
print(" " * (err.column - 1) + "^")
print(err)
def __init__(self, tree):
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean!=None:
type_='ASK'
elif results!=None:
type_='SELECT'
else:
raise ResultException("No result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_=='SELECT':
self.bindings=[]
for result in results:
r = {}
for binding in result:
r[binding.get('name')] = parseTerm(binding[0])
self.bindings.append(r)
self.vars=[x.get("name") for x in tree.findall(RESULTS_NS_ET+'head')]
elif type_=='ASK':
self.askAnswer=bool(boolean.text)
def __init__(self, source, content_type=None):
tree = etree.parse(source)
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean is not None:
type_ = 'ASK'
elif results is not None:
type_ = 'SELECT'
else:
raise ResultException(
"No RDF result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == 'SELECT':
self.bindings = []
for result in results:
r = {}
for binding in result:
r[Variable(binding.get('name'))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [
Variable(x.get("name"))
for x in tree.findall('./%shead/%svariable' %
(RESULTS_NS_ET, RESULTS_NS_ET))
]
else:
self.askAnswer = boolean.text.lower().strip() == "true"
def parse(self, source):
try:
r = Result('SELECT')
header = source.readline()
r.vars = list(HEADER.parseString(header.strip(), parseAll=True))
r.bindings = []
while True:
line = source.readline()
if not line:
break
line = line.strip()
if line == "":
continue
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(zip(r.vars, (self.convertTerm(x) for x in row))))
return r
except ParseException, err:
print err.line
print " " * (err.column - 1) + "^"
print err
def parse(self, source, content_type):
res = Result('CONSTRUCT') # hmm - or describe?type_)
res.graph = Graph()
res.graph.parse(source, format=content_type)
return res
def parse(self, source):
try:
r = Result('SELECT')
header = source.readline()
r.vars = list(HEADER.parseString(header.strip(), parseAll=True))
r.bindings = []
while True:
line = source.readline()
if not line:
break
line = line.strip()
if line == "":
continue
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(zip(r.vars, (self.convertTerm(x) for x in row))))
return r
except ParseException, err:
print err.line
print " " * (err.column - 1) + "^"
print err
def parse(self, source):
if isinstance(source.read(0), bytestype):
# if reading from source returns bytes do utf-8 decoding
source = codecs.getreader('utf-8')(source)
try:
r = Result('SELECT')
header = source.readline()
r.vars = list(HEADER.parseString(header.strip(), parseAll=True))
r.bindings = []
while True:
line = source.readline()
if not line:
break
line = line.strip('\n')
if line == "":
continue
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(zip(r.vars, (self.convertTerm(x) for x in row))))
return r
except ParseException, err:
print err.line
print " " * (err.column - 1) + "^"
print err
def parse(self, source):
r = Result('SELECT')
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in reader.next()]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def parse(self, source):
r = Result('SELECT')
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in next(reader)]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def __init__(self, source):
xmlstring = source.read()
if isinstance(xmlstring, text_type):
xmlstring = xmlstring.encode('utf-8')
try:
parser = etree.XMLParser(huge_tree=True)
tree = etree.parse(BytesIO(xmlstring), parser)
except TypeError:
tree = etree.fromstring(xmlstring)
except Exception as e:
log.exception("Error parsing XML results: %s" % xmlstring)
raise e
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean is not None:
type_ = 'ASK'
elif results is not None:
type_ = 'SELECT'
else:
g = Graph()
try:
g.parse(data=xmlstring)
if len(g) == 0:
raise
type_ = 'CONSTRUCT'
except:
raise ResultException(
"No RDF Graph, result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == 'SELECT':
self.bindings = []
for result in results:
r = {}
for binding in result:
r[Variable(binding.get('name'))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [
Variable(x.get("name"))
for x in tree.findall('./%shead/%svariable' %
(RESULTS_NS_ET, RESULTS_NS_ET))
]
elif type_ == 'ASK':
self.askAnswer = boolean.text.lower().strip() == "true"
elif type_ == 'CONSTRUCT':
self.graph = g
def __init__(self, source):
xmlstring = source.read()
if isinstance(xmlstring, text_type):
xmlstring = xmlstring.encode('utf-8')
try:
parser = etree.XMLParser(huge_tree=True)
tree = etree.parse(BytesIO(xmlstring), parser)
except TypeError:
tree = etree.fromstring(xmlstring)
except Exception as e:
log.exception("Error parsing XML results: %s"%xmlstring)
raise e
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean is not None:
type_ = 'ASK'
elif results is not None:
type_ = 'SELECT'
else:
g = Graph()
try:
g.parse(data=xmlstring)
if len(g) == 0:
raise
type_ = 'CONSTRUCT'
except:
raise ResultException(
"No RDF Graph, result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == 'SELECT':
self.bindings = []
for result in results:
r = {}
for binding in result:
r[Variable(binding.get('name'))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [Variable(x.get("name"))
for x in tree.findall(
'./%shead/%svariable' % (
RESULTS_NS_ET, RESULTS_NS_ET))]
elif type_ == 'ASK':
self.askAnswer = boolean.text.lower().strip() == "true"
elif type_ == 'CONSTRUCT':
self.graph = g
def __init__(self, source):
xmlstring = source.read()
if isinstance(xmlstring, str):
xmlstring = xmlstring.encode('utf-8')
try:
tree = ElementTree.fromstring(xmlstring)
except Exception as e:
try:
raise e.__class__("error parsing %r: %s" % (xmlstring, e))
except:
raise e
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean != None:
type_ = 'ASK'
elif results != None:
type_ = 'SELECT'
else:
g = Graph()
try:
g.parse(data=xmlstring)
if len(g) == 0:
raise
type_ = 'CONSTRUCT'
except:
raise ResultException(
"No RDF Graph, result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == 'SELECT':
self.bindings = []
for result in results:
r = {}
for binding in result:
r[Variable(binding.get('name'))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [
Variable(x.get("name"))
for x in tree.findall('./%shead/%svariable' %
(RESULTS_NS_ET, RESULTS_NS_ET))
]
elif type_ == 'ASK':
self.askAnswer = boolean.text.lower().strip() == "true"
elif type_ == 'CONSTRUCT':
self.graph = g
def parse(self, source):
r = Result('SELECT')
if hasattr(source, 'mode') and 'b' in source.mode:
source = codecs.getreader('utf-8')(source)
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in reader.next()]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def __init__(self, json):
self.json=json
if "boolean" in json:
type_='ASK'
elif "results" in json:
type_='SELECT'
else:
raise ResultException('No boolean or results in json!')
Result.__init__(self,type_)
if type_=='ASK':
self.askAnswer=bool(json['boolean'])
else:
self.bindings=self._get_bindings()
def parse(self, source):
r = Result("SELECT")
if hasattr(source, "mode") and "b" in source.mode:
source = codecs.getreader("utf-8")(source)
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in reader.next()]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def __init__(self, json):
self.json = json
if "boolean" in json:
type_ = 'ASK'
elif "results" in json:
type_ = 'SELECT'
else:
raise ResultException('No boolean or results in json!')
Result.__init__(self, type_)
if type_ == 'ASK':
self.askAnswer = bool(json['boolean'])
else:
self.bindings = self._get_bindings()
def __init__(self, source, **kwargs):
if not isinstance(source, Graph):
graph = Graph()
graph.load(source, **kwargs)
else:
graph = source
rs = graph.value(predicate=RDF.type, object=RS.ResultSet)
# there better be only one :)
if rs is None:
type_ = 'CONSTRUCT'
# use a new graph
g = Graph()
g += graph
else:
askAnswer = graph.value(rs, RS.boolean)
if askAnswer is not None:
type_ = 'ASK'
else:
type_ = 'SELECT'
Result.__init__(self, type_)
if type_ == 'SELECT':
self.vars = [
Variable(v) for v in graph.objects(rs, RS.resultVariable)
]
self.bindings = []
for s in graph.objects(rs, RS.solution):
sol = {}
for b in graph.objects(s, RS.binding):
sol[Variable(graph.value(b, RS.variable))] = graph.value(
b, RS.value)
self.bindings.append(sol)
elif type_ == 'ASK':
self.askAnswer = askAnswer.value
if askAnswer.value == None:
raise Exception('Malformed boolean in ask answer!')
elif type_ == 'CONSTRUCT':
self.graph = g
def query(self,
query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query += "\nVALUES ( %s )\n{ ( %s ) }\n"\
% (" ".join("?" + str(x) for x in v),
" ".join(self.node_to_sparql(initBindings[x]) for x in v))
self.resetQuery()
self.setMethod(self.query_method)
if self._is_contextual(queryGraph):
self.addParameter("default-graph-uri", queryGraph)
self.timeout = self._timeout
self.setQuery(query)
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
return Result.parse(res)
def __init__(self, json):
self.json = json
if "boolean" in json:
type_ = "ASK"
elif "results" in json:
type_ = "SELECT"
else:
raise ResultException("No boolean or results in json!")
Result.__init__(self, type_)
if type_ == "ASK":
self.askAnswer = bool(json["boolean"])
else:
self.bindings = self._get_bindings()
self.vars = [Variable(x) for x in json["head"]["vars"]]
def query(self, query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query += "\nVALUES ( %s )\n{ ( %s ) }\n"\
% (" ".join("?" + str(x) for x in v),
" ".join(self.node_to_sparql(initBindings[x]) for x in v))
self.resetQuery()
if self._is_contextual(queryGraph):
self.addParameter("default-graph-uri", queryGraph)
self.timeout = self._timeout
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def query(self, query, default_graph=None):
if not self.query_endpoint:
raise SPARQLConnectorException("Query endpoint not set!")
params = {"query": query}
if default_graph:
params["default-graph-uri"] = default_graph
headers = {"Accept": _response_mime_types[self.returnFormat]}
args = dict(self.kwargs)
args.update(url=self.query_endpoint)
# merge params/headers dicts
args.setdefault("params", {})
args.setdefault("headers", {})
args["headers"].update(headers)
if self.method == "GET":
args["params"].update(params)
elif self.method == "POST":
args["headers"].update(
{"Content-Type": "application/sparql-query"})
args["data"] = params
else:
raise SPARQLConnectorException("Unknown method %s" % self.method)
res = self.session.request(self.method, **args)
res.raise_for_status()
return Result.parse(BytesIO(res.content),
content_type=res.headers["Content-type"])
def parse(self, source):
r = Result('SELECT')
if isinstance(source.read(0), py3compat.bytestype):
# if reading from source returns bytes do utf-8 decoding
source = codecs.getreader('utf-8')(source)
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in reader.next()]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def parse(self, source):
r = Result('SELECT')
if isinstance(source.read(0), binary_type):
# if reading from source returns bytes do utf-8 decoding
source = codecs.getreader('utf-8')(source)
reader = csv.reader(source, delimiter=self.delim)
r.vars = [Variable(x) for x in next(reader)]
r.bindings = []
for row in reader:
r.bindings.append(self.parseRow(row, r.vars))
return r
def query(self, query, default_graph=None):
if not self.query_endpoint:
raise SPARQLConnectorException("Query endpoint not set!")
params = {'query': query}
if default_graph:
params["default-graph-uri"] = default_graph
headers = {'Accept': _response_mime_types[self.returnFormat]}
args = dict(self.kwargs)
args.update(url=self.query_endpoint)
# merge params/headers dicts
args.setdefault('params', {})
args.setdefault('headers', {})
args['headers'].update(headers)
if self.method == 'GET':
args['params'].update(params)
elif self.method == 'POST':
args['data'] = params
else:
raise SPARQLConnectorException("Unknown method %s" % self.method)
res = self.session.request(self.method, **args)
res.raise_for_status()
return Result.parse(BytesIO(res.content), content_type=res.headers['Content-type'])
def contexts(self, triple=None):
"""
Iterates over results to "SELECT ?NAME { GRAPH ?NAME { ?s ?p ?o } }"
or "SELECT ?NAME { GRAPH ?NAME {} }" if triple is `None`.
Returns instances of this store with the SPARQL wrapper
object updated via addNamedGraph(?NAME).
This causes a named-graph-uri key / value pair to be sent over
the protocol.
Please note that some SPARQL endpoints are not able to find empty named
graphs.
"""
self.resetQuery()
if triple:
nts = self.node_to_sparql
s, p, o = triple
params = (nts(s if s else Variable('s')),
nts(p if p else Variable('p')),
nts(o if o else Variable('o')))
self.setQuery('SELECT ?name WHERE { GRAPH ?name { %s %s %s }}' %
params)
else:
self.setQuery('SELECT ?name WHERE { GRAPH ?name {} }')
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
result = Result.parse(res, format=self.returnFormat)
return (row.name for row in result)
def query(self, query, default_graph=None):
if not self.query_endpoint:
raise SPARQLConnectorException("Query endpoint not set!")
params = {'query': query}
if default_graph:
params["default-graph-uri"] = default_graph
headers = {'Accept': _response_mime_types[self.returnFormat]}
args = dict(self.kwargs)
args.update(url=self.query_endpoint)
# merge params/headers dicts
args.setdefault('params', {})
args.setdefault('headers', {})
args['headers'].update(headers)
if self.method == 'GET':
args['params'].update(params)
elif self.method == 'POST':
args['headers'].update({'Content-Type': 'application/sparql-query'})
args['data'] = params
else:
raise SPARQLConnectorException("Unknown method %s" % self.method)
res = self.session.request(self.method, **args)
res.raise_for_status()
return Result.parse(BytesIO(res.content), content_type=res.headers['Content-type'])
def query(self,
query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query += "\nVALUES ( %s )\n{ ( %s ) }\n"\
% (" ".join("?" + str(x) for x in v),
" ".join(initBindings[x].n3() for x in v))
self.resetQuery()
if self._is_contextual(queryGraph):
self.addDefaultGraph(queryGraph)
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def query(self, query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query += "\nVALUES ( %s )\n{ ( %s ) }\n"\
% (" ".join("?" + str(x) for x in v),
" ".join(initBindings[x].n3() for x in v))
self.resetQuery()
if self.context_aware and queryGraph and queryGraph != '__UNION__':
self.addDefaultGraph(queryGraph)
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def query(self,
query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring), 'Query is not a string'
self.setNamespaceBindings(initNs)
if initBindings:
query = self.inject_sparql_bindings(query, initBindings)
self.resetQuery()
if self.context_aware and queryGraph and queryGraph != '__UNION__':
# we care about context
if not re.search('[\s{]GRAPH[{\s]', query, flags=re.I):
# if a GRAPH clause was already specified, move on...
# insert GRAPH clause after/before first/last { }
# not 100% sure how rock-steady this is
i1 = query.index("{") + 1
i2 = query.rindex("}")
query = query[:i1] + ' GRAPH %s { ' % queryGraph.n3() + \
query[i1:i2] + ' } ' + query[i2:]
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def contexts(self, triple=None):
"""
Iterates over results to "SELECT ?NAME { GRAPH ?NAME { ?s ?p ?o } }"
or "SELECT ?NAME { GRAPH ?NAME {} }" if triple is `None`.
Returns instances of this store with the SPARQL wrapper
object updated via addNamedGraph(?NAME).
This causes a named-graph-uri key / value pair to be sent over
the protocol.
Please note that some SPARQL endpoints are not able to find empty named
graphs.
"""
self.resetQuery()
if triple:
nts = self.node_to_sparql
s, p, o = triple
params = (nts(s if s else Variable('s')),
nts(p if p else Variable('p')),
nts(o if o else Variable('o')))
self.setQuery('SELECT ?name WHERE { GRAPH ?name { %s %s %s }}' % params)
else:
self.setQuery('SELECT ?name WHERE { GRAPH ?name {} }')
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
result = Result.parse(res, format=self.returnFormat)
return ( row.name for row in result )
def __init__(self, source, **kwargs):
if not isinstance(source, Graph):
graph = Graph()
graph.load(source, **kwargs)
else:
graph = source
rs = graph.value(predicate=RDF.type, object=RS.ResultSet)
# there better be only one :)
if rs is None:
type_ = 'CONSTRUCT'
# use a new graph
g = Graph()
g += graph
else:
askAnswer = graph.value(rs, RS.boolean)
if askAnswer is not None:
type_ = 'ASK'
else:
type_ = 'SELECT'
Result.__init__(self, type_)
if type_ == 'SELECT':
self.vars = [Variable(v) for v in graph.objects(rs,
RS.resultVariable)]
self.bindings = []
for s in graph.objects(rs, RS.solution):
sol = {}
for b in graph.objects(s, RS.binding):
sol[Variable(graph.value(
b, RS.variable))] = graph.value(b, RS.value)
self.bindings.append(sol)
elif type_ == 'ASK':
self.askAnswer = askAnswer.value
if askAnswer.value == None:
raise Exception('Malformed boolean in ask answer!')
elif type_ == 'CONSTRUCT':
self.graph = g
def query(self, query, default_graph: str = None, named_graph: str = None):
if not self.query_endpoint:
raise SPARQLConnectorException("Query endpoint not set!")
params = {}
# this test ensures we don't have a useless (BNode) default graph URI, which calls to Graph().query() will add
if default_graph is not None and type(default_graph) != BNode:
params["default-graph-uri"] = default_graph
headers = {"Accept": _response_mime_types[self.returnFormat]}
args = dict(self.kwargs)
# merge params/headers dicts
args.setdefault("params", {})
args.setdefault("headers", {})
args["headers"].update(headers)
if self.method == "GET":
params["query"] = query
args["params"].update(params)
qsa = "?" + urlencode(args["params"])
try:
res = urlopen(
Request(self.query_endpoint + qsa,
headers=args["headers"]))
except Exception as e:
raise ValueError(
"You did something wrong formulating either the URI or your SPARQL query"
)
elif self.method == "POST":
args["headers"].update(
{"Content-Type": "application/sparql-query"})
qsa = "?" + urlencode(params)
try:
res = urlopen(
Request(self.query_endpoint + qsa,
data=query.encode(),
headers=args["headers"]))
except HTTPError as e:
return e.code, str(e), None
elif self.method == "POST_FORM":
params["query"] = query
args["params"].update(params)
try:
res = urlopen(
Request(self.query_endpoint,
data=urlencode(args["params"]).encode(),
headers=args["headers"]))
except HTTPError as e:
return e.code, str(e), None
else:
raise SPARQLConnectorException("Unknown method %s" % self.method)
return Result.parse(
BytesIO(res.read()),
content_type=res.headers["Content-Type"].split(";")[0])
def __iter__(self):
"""
Iter over all bindings as tuples of rdflib Terms.
"""
if self.type != "SELECT":
return Result.__iter__(self)
elif self._bindings_tuples is not None:
if not self._bindings_tuples_complete:
raise ValueError("Can not access bindings while iterating")
return iter(self._bindings_tuples)
else:
self._bindings_tuples = []
return self._iter_tuples()
def __iter__(self):
"""
Iter over all bindings as tuples of rdflib Terms.
"""
if self.type != "SELECT":
return Result.__iter__(self)
elif self._bindings_tuples is not None:
if not self._bindings_tuples_complete:
raise ValueError("Can not access bindings while iterating")
return iter(self._bindings_tuples)
else:
self._bindings_tuples = []
return self._iter_tuples()
def __init__(self, source, content_type: Optional[str] = None):
try:
# try use as if etree is from lxml, and if not use it as normal.
parser = etree.XMLParser(huge_tree=True) # type: ignore[call-arg]
tree = etree.parse(source, parser)
except TypeError:
tree = etree.parse(source)
boolean = tree.find(RESULTS_NS_ET + "boolean")
results = tree.find(RESULTS_NS_ET + "results")
if boolean is not None:
type_ = "ASK"
elif results is not None:
type_ = "SELECT"
else:
raise ResultException("No RDF result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == "SELECT":
self.bindings = []
for result in results: # type: ignore[union-attr]
r = {}
for binding in result:
r[Variable(binding.get("name"))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [
Variable(x.get("name"))
for x in tree.findall(
"./%shead/%svariable" % (RESULTS_NS_ET, RESULTS_NS_ET)
)
]
else:
self.askAnswer = boolean.text.lower().strip() == "true" # type: ignore[union-attr]
def check_violations(self):
res = []
headers = {
'Content-Type':
'application/x-turtle, text/turtle, application/rdf+xml'
}
req = requests.post(
'http://*****:*****@localhost:5820/test-haris/icv/violations',
headers=headers)
resp = decoder.MultipartDecoder.from_response(req)
for p in resp.parts:
print(p.headers)
#if "rdf+xml" in p.headers["Content-Type"]:
# g = Graph()
# g.parse(data=p.content, format=p.headers["Content-Type"])
if "sparql-result" in p.headers["Content-Type"]:
g = Result('SELECT')
g = g.parse(StringIO.StringIO(
p.content)) # , format=p.headers["Content-Type"])
for r in g:
res.append({"type": "path", "entity": r["path"]})
return res
async def queryGraph(self, query: str, *args, **keywords) -> dict:
try:
j = await self.query(query, *args, **keywords)
data = io.BytesIO()
data.write(orjson.dumps(j))
data.seek(0, 0)
except Exception:
return None
else:
graph = BaseGraph()
results = Result.parse(data, format='json')
graph.parse(data=results.serialize(format='xml').decode(),
format='xml')
return graph
def __init__(self, source, content_type=None):
try:
parser = etree.XMLParser(huge_tree=True)
tree = etree.parse(source, parser)
except TypeError:
tree = etree.parse(source)
boolean = tree.find(RESULTS_NS_ET + 'boolean')
results = tree.find(RESULTS_NS_ET + 'results')
if boolean is not None:
type_ = 'ASK'
elif results is not None:
type_ = 'SELECT'
else:
raise ResultException(
"No RDF result-bindings or boolean answer found!")
Result.__init__(self, type_)
if type_ == 'SELECT':
self.bindings = []
for result in results:
r = {}
for binding in result:
r[Variable(binding.get('name'))] = parseTerm(binding[0])
self.bindings.append(r)
self.vars = [Variable(x.get("name"))
for x in tree.findall(
'./%shead/%svariable' % (
RESULTS_NS_ET, RESULTS_NS_ET))]
else:
self.askAnswer = boolean.text.lower().strip() == "true"
def __len__(self, context=None):
if not self.sparql11:
raise NotImplementedError("For performance reasons, this is not" +
"supported for sparql1.0 endpoints")
else:
self.resetQuery()
q = "SELECT (count(*) as ?c) WHERE {?s ?p ?o .}"
if self._is_contextual(context):
self.addParameter("default-graph-uri", context.identifier)
self.setQuery(q)
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
result = Result.parse(res, format=self.returnFormat)
return int(next(iter(result)).c)
def __len__(self, context=None):
if not self.sparql11:
raise NotImplementedError(
"For performance reasons, this is not" +
"supported for sparql1.0 endpoints")
else:
self.resetQuery()
q = "SELECT (count(*) as ?c) WHERE {?s ?p ?o .}"
if self._is_contextual(context):
self.addParameter("default-graph-uri", context.identifier)
self.setQuery(q)
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
result = Result.parse(res, format=self.returnFormat)
return int(next(iter(result)).c)
def __init__(self, inner_result):
if type(inner_result) is EagerIterator:
Result.__init__(self, "SELECT")
self._eagerIterator = inner_result
self.vars = inner_result.vars
elif type(inner_result) is bool:
Result.__init__(self, "ASK")
self.askAnswer = inner_result
elif type(inner_result) is Graph:
Result.__init__(self, "CONSTRUCT")
self.graph = inner_result
else:
raise ValueError("Unrecognized inner_result %r" % inner_result)
def __init__(self, inner_result):
if type(inner_result) is EagerIterator:
Result.__init__(self, "SELECT")
self._eagerIterator = inner_result
self.vars = inner_result.vars
elif type(inner_result) is bool:
Result.__init__(self, "ASK")
self.askAnswer = inner_result
elif type(inner_result) is Graph:
Result.__init__(self, "CONSTRUCT")
self.graph = inner_result
else:
raise ValueError("Unrecognized inner_result %r" % inner_result)
def query(self,
query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query+="\nVALUES ( %s )\n{ ( %s ) }\n"\
%(" ".join("?"+str(x) for x in v),
" ".join(initBindings[x].n3() for x in v))
self.resetQuery()
if self.context_aware and queryGraph and queryGraph != '__UNION__':
# we care about context
if not re.search('[\s{]GRAPH[{\s]', query, flags=re.I):
# if a GRAPH clause was already specified, move on...
# insert GRAPH clause after/before first/last { }
# not 100% sure how rock-steady this is
i1 = query.index("{") + 1
i2 = query.rindex("}")
query=query[:i1]+' GRAPH %s { '%queryGraph.n3()+\
query[i1:i2]+' } '+query[i2:]
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def query(self, query,
initNs={},
initBindings={},
queryGraph=None,
DEBUG=False):
self.debug = DEBUG
assert isinstance(query, basestring)
self.setNamespaceBindings(initNs)
if initBindings:
if not self.sparql11:
raise Exception(
"initBindings not supported for SPARQL 1.0 Endpoints.")
v = list(initBindings)
# VALUES was added to SPARQL 1.1 on 2012/07/24
query += "\nVALUES ( %s )\n{ ( %s ) }\n"\
% (" ".join("?" + str(x) for x in v),
" ".join(initBindings[x].n3() for x in v))
self.resetQuery()
if self.context_aware and queryGraph and queryGraph != '__UNION__':
# we care about context
if not re.search('[\s{]GRAPH[{\s]', query, flags=re.I):
# if a GRAPH clause was already specified, move on...
# insert GRAPH clause after/before first/last { }
# not 100% sure how rock-steady this is
i1 = query.index("{") + 1
i2 = query.rindex("}")
query = query[:i1] + ' GRAPH %s { ' % queryGraph.n3() + \
query[i1:i2] + ' } ' + query[i2:]
self.setQuery(query)
return Result.parse(SPARQLWrapper.query(self).response)
def query_test(t):
uri, name, comment, data, graphdata, query, resfile, syntax = t
# the query-eval tests refer to graphs to load by resolvable filenames
rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True
if uri in skiptests:
raise SkipTest()
def skip(reason='(none)'):
print "Skipping %s from now on." % uri
f = open("skiptests.list", "a")
f.write("%s\t%s\n" % (uri, reason))
f.close()
try:
g = Dataset()
if data:
g.default_context.load(data, format=_fmt(data))
if graphdata:
for x in graphdata:
g.load(x, format=_fmt(x))
if not resfile:
# no result - syntax test
if syntax:
translateQuery(parseQuery(
open(query[7:]).read()), base=urljoin(query, '.'))
else:
# negative syntax test
try:
translateQuery(parseQuery(
open(query[7:]).read()), base=urljoin(query, '.'))
assert False, 'Query should not have parsed!'
except:
pass # it's fine - the query should not parse
return
# eval test - carry out query
res2 = g.query(open(query[7:]).read(), base=urljoin(query, '.'))
if resfile.endswith('ttl'):
resg = Graph()
resg.load(resfile, format='turtle', publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('rdf'):
resg = Graph()
resg.load(resfile, publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('srj'):
res = Result.parse(open(resfile[7:]), format='json')
elif resfile.endswith('tsv'):
res = Result.parse(open(resfile[7:]), format='tsv')
elif resfile.endswith('csv'):
res = Result.parse(open(resfile[7:]), format='csv')
# CSV is lossy, round-trip our own resultset to
# lose the same info :)
# write bytes, read strings...
s = BytesIO()
res2.serialize(s, format='csv')
print s.getvalue()
s = StringIO(s.getvalue().decode('utf-8')) # hmm ?
res2 = Result.parse(s, format='csv')
else:
res = Result.parse(open(resfile[7:]), format='xml')
if not DETAILEDASSERT:
eq(res.type, res2.type, 'Types do not match')
if res.type == 'SELECT':
eq(set(res.vars), set(res2.vars), 'Vars do not match')
comp = bindingsCompatible(
set(res),
set(res2)
)
assert comp, 'Bindings do not match'
elif res.type == 'ASK':
eq(res.askAnswer, res2.askAnswer, 'Ask answer does not match')
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(
res.graph, res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
else:
eq(res.type, res2.type,
'Types do not match: %r != %r' % (res.type, res2.type))
if res.type == 'SELECT':
eq(set(res.vars),
set(res2.vars), 'Vars do not match: %r != %r' % (
set(res.vars), set(res2.vars)))
assert bindingsCompatible(
set(res),
set(res2)
), 'Bindings do not match: \n%s\n!=\n%s' % (
res.serialize(format='txt', namespace_manager=g.namespace_manager),
res2.serialize(format='txt', namespace_manager=g.namespace_manager))
elif res.type == 'ASK':
eq(res.askAnswer,
res2.askAnswer, "Ask answer does not match: %r != %r" % (
res.askAnswer, res2.askAnswer))
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(
res.graph, res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
except Exception, e:
if isinstance(e, AssertionError):
failed_tests.append(uri)
fails[str(e)] += 1
else:
error_tests.append(uri)
errors[str(e)] += 1
if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL:
print "======================================"
print uri
print name
print comment
if not resfile:
if syntax:
print "Positive syntax test"
else:
print "Negative syntax test"
if data:
print "----------------- DATA --------------------"
print ">>>", data
print open(data[7:]).read()
if graphdata:
print "----------------- GRAPHDATA --------------------"
for x in graphdata:
print ">>>", x
print open(x[7:]).read()
print "----------------- Query -------------------"
print ">>>", query
print open(query[7:]).read()
if resfile:
print "----------------- Res -------------------"
print ">>>", resfile
print open(resfile[7:]).read()
try:
pq = parseQuery(open(query[7:]).read())
print "----------------- Parsed ------------------"
pprintAlgebra(translateQuery(pq, base=urljoin(query, '.')))
except:
print "(parser error)"
print decodeStringEscape(unicode(e))
import pdb
pdb.post_mortem(sys.exc_info()[2])
# pdb.set_trace()
# nose.tools.set_trace()
raise
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(zip(r.vars, (self.convertTerm(x) for x in row))))
return r
except ParseException, err:
print err.line
print " " * (err.column - 1) + "^"
print err
def convertTerm(self, t):
if t is NONE_VALUE:
return None
if isinstance(t, CompValue):
if t.name == 'literal':
return RDFLiteral(t.string, lang=t.lang, datatype=t.datatype)
else:
raise Exception("I dont know how to handle this: %s" % (t, ))
else:
return t
if __name__ == '__main__':
import sys
r = Result.parse(file(sys.argv[1]), format='tsv')
print r.vars
print r.bindings
# print r.serialize(format='json')
line = line.strip()
if line == "":
continue
row = ROW.parseString(line, parseAll=True)
r.bindings.append(
dict(zip(r.vars, (self.convertTerm(x) for x in row))))
return r
except ParseException, err:
print err.line
print " " * (err.column - 1) + "^"
print err
def convertTerm(self, t):
if isinstance(t, CompValue):
if t.name == 'literal':
return RDFLiteral(t.string, lang=t.lang, datatype=t.datatype)
else:
raise Exception("I dont know how to handle this: %s" % (t,))
else:
return t
if __name__ == '__main__':
import sys
r = Result.parse(file(sys.argv[1]), format='tsv')
print r.vars
print r.bindings
#print r.serialize(format='json')
def query_test(t):
uri, name, comment, data, graphdata, query, resfile, syntax = t
# the query-eval tests refer to graphs to load by resolvable filenames
rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True
if uri in skiptests:
raise SkipTest()
def skip(reason="(none)"):
print("Skipping %s from now on." % uri)
with bopen("skiptests.list", "a") as f:
f.write("%s\t%s\n" % (uri, reason))
try:
g = Dataset()
if data:
g.default_context.load(data, format=_fmt(data))
if graphdata:
for x in graphdata:
g.load(x, format=_fmt(x))
if not resfile:
# no result - syntax test
if syntax:
translateQuery(parseQuery(bopen_read_close(query[7:])),
base=urljoin(query, "."))
else:
# negative syntax test
try:
translateQuery(
parseQuery(bopen_read_close(query[7:])),
base=urljoin(query, "."),
)
assert False, "Query should not have parsed!"
except:
pass # it's fine - the query should not parse
return
# eval test - carry out query
res2 = g.query(bopen_read_close(query[7:]), base=urljoin(query, "."))
if resfile.endswith("ttl"):
resg = Graph()
resg.load(resfile, format="turtle", publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith("rdf"):
resg = Graph()
resg.load(resfile, publicID=resfile)
res = RDFResultParser().parse(resg)
else:
with bopen(resfile[7:]) as f:
if resfile.endswith("srj"):
res = Result.parse(f, format="json")
elif resfile.endswith("tsv"):
res = Result.parse(f, format="tsv")
elif resfile.endswith("csv"):
res = Result.parse(f, format="csv")
# CSV is lossy, round-trip our own resultset to
# lose the same info :)
# write bytes, read strings...
s = BytesIO()
res2.serialize(s, format="csv")
s.seek(0)
res2 = Result.parse(s, format="csv")
s.close()
else:
res = Result.parse(f, format="xml")
if not DETAILEDASSERT:
eq(res.type, res2.type, "Types do not match")
if res.type == "SELECT":
eq(set(res.vars), set(res2.vars), "Vars do not match")
comp = bindingsCompatible(set(res), set(res2))
assert comp, "Bindings do not match"
elif res.type == "ASK":
eq(res.askAnswer, res2.askAnswer, "Ask answer does not match")
elif res.type in ("DESCRIBE", "CONSTRUCT"):
assert isomorphic(res.graph,
res2.graph), "graphs are not isomorphic!"
else:
raise Exception("Unknown result type: %s" % res.type)
else:
eq(
res.type,
res2.type,
"Types do not match: %r != %r" % (res.type, res2.type),
)
if res.type == "SELECT":
eq(
set(res.vars),
set(res2.vars),
"Vars do not match: %r != %r" %
(set(res.vars), set(res2.vars)),
)
assert bindingsCompatible(set(res), set(res2)), (
"Bindings do not match: \nexpected:\n%s\n!=\ngot:\n%s" % (
res.serialize(format="txt",
namespace_manager=g.namespace_manager),
res2.serialize(format="txt",
namespace_manager=g.namespace_manager),
))
elif res.type == "ASK":
eq(
res.askAnswer,
res2.askAnswer,
"Ask answer does not match: %r != %r" %
(res.askAnswer, res2.askAnswer),
)
elif res.type in ("DESCRIBE", "CONSTRUCT"):
assert isomorphic(res.graph,
res2.graph), "graphs are not isomorphic!"
else:
raise Exception("Unknown result type: %s" % res.type)
except Exception as e:
if isinstance(e, AssertionError):
failed_tests.append(uri)
fails[str(e)] += 1
else:
error_tests.append(uri)
errors[str(e)] += 1
if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL:
print("======================================")
print(uri)
print(name)
print(comment)
if not resfile:
if syntax:
print("Positive syntax test")
else:
print("Negative syntax test")
if data:
print("----------------- DATA --------------------")
print(">>>", data)
print(bopen_read_close(data[7:]))
if graphdata:
print("----------------- GRAPHDATA --------------------")
for x in graphdata:
print(">>>", x)
print(bopen_read_close(x[7:]))
print("----------------- Query -------------------")
print(">>>", query)
print(bopen_read_close(query[7:]))
if resfile:
print("----------------- Res -------------------")
print(">>>", resfile)
print(bopen_read_close(resfile[7:]))
try:
pq = parseQuery(bopen_read_close(query[7:]))
print("----------------- Parsed ------------------")
pprintAlgebra(translateQuery(pq, base=urljoin(query, ".")))
except:
print("(parser error)")
print(decodeStringEscape(str(e)))
import pdb
pdb.post_mortem(sys.exc_info()[2])
# pdb.set_trace()
# nose.tools.set_trace()
raise
def __init__(self, res):
Result.__init__(self, res["type_"])
self.vars = res.get("vars_")
self.bindings = res.get("bindings")
self.askAnswer = res.get("askAnswer")
self.graph = res.get("graph")
def __len__(self):
try:
return Result.__len__(self)
except ValueError:
return None # __len__ called during __iter__
def _parse_response(cls, rsp):
return list(Result.parse(rsp.buffer))
def query_test(t):
uri, name, comment, data, graphdata, query, resfile, syntax = t
# the query-eval tests refer to graphs to load by resolvable filenames
rdflib_sparql_module.SPARQL_LOAD_GRAPHS = True
if uri in skiptests:
raise SkipTest()
def skip(reason='(none)'):
print "Skipping %s from now on." % uri
f = open("skiptests.list", "a")
f.write("%s\t%s\n" % (uri, reason))
f.close()
try:
g = ConjunctiveGraph()
if data:
g.default_context.load(data, format=_fmt(data))
if graphdata:
for x in graphdata:
g.load(x, format=_fmt(x))
if not resfile:
# no result - syntax test
if syntax:
translateQuery(parseQuery(open(query[7:]).read()),
base=urljoin(query, '.'))
else:
# negative syntax test
try:
translateQuery(parseQuery(open(query[7:]).read()),
base=urljoin(query, '.'))
assert False, 'Query should not have parsed!'
except:
pass # it's fine - the query should not parse
return
# eval test - carry out query
res2 = g.query(open(query[7:]).read(), base=urljoin(query, '.'))
if resfile.endswith('ttl'):
resg = Graph()
resg.load(resfile, format='turtle', publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('rdf'):
resg = Graph()
resg.load(resfile, publicID=resfile)
res = RDFResultParser().parse(resg)
elif resfile.endswith('srj'):
res = Result.parse(open(resfile[7:]), format='json')
elif resfile.endswith('tsv'):
res = Result.parse(open(resfile[7:]), format='tsv')
elif resfile.endswith('csv'):
res = Result.parse(open(resfile[7:]), format='csv')
# CSV is lossy, round-trip our own resultset to
# lose the same info :)
# write bytes, read strings...
s = BytesIO()
res2.serialize(s, format='csv')
print s.getvalue()
s = StringIO(s.getvalue().decode('utf-8')) # hmm ?
res2 = Result.parse(s, format='csv')
else:
res = Result.parse(open(resfile[7:]), format='xml')
if not DETAILEDASSERT:
eq(res.type, res2.type, 'Types do not match')
if res.type == 'SELECT':
eq(set(res.vars), set(res2.vars), 'Vars do not match')
comp = bindingsCompatible(
set(frozenset(x.iteritems()) for x in res.bindings),
set(frozenset(x.iteritems()) for x in res2.bindings))
assert comp, 'Bindings do not match'
elif res.type == 'ASK':
eq(res.askAnswer, res2.askAnswer, 'Ask answer does not match')
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(res.graph,
res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
else:
eq(res.type, res2.type,
'Types do not match: %r != %r' % (res.type, res2.type))
if res.type == 'SELECT':
eq(
set(res.vars), set(res2.vars),
'Vars do not match: %r != %r' %
(set(res.vars), set(res2.vars)))
assert bindingsCompatible(
set(frozenset(x.iteritems()) for x in res.bindings),
set(frozenset(x.iteritems()) for x in res2.bindings)
), 'Bindings do not match: \n%s\n!=\n%s' % (_bindingsTable(
res.bindings), _bindingsTable(res2.bindings))
elif res.type == 'ASK':
eq(
res.askAnswer, res2.askAnswer,
"Ask answer does not match: %r != %r" %
(res.askAnswer, res2.askAnswer))
elif res.type in ('DESCRIBE', 'CONSTRUCT'):
assert isomorphic(res.graph,
res2.graph), 'graphs are not isomorphic!'
else:
raise Exception('Unknown result type: %s' % res.type)
except Exception, e:
if isinstance(e, AssertionError):
failed_tests.append(uri)
fails[str(e)] += 1
else:
error_tests.append(uri)
errors[str(e)] += 1
if DEBUG_ERROR and not isinstance(e, AssertionError) or DEBUG_FAIL:
print "======================================"
print uri
print name
print comment
if not resfile:
if syntax:
print "Positive syntax test"
else:
print "Negative syntax test"
if data:
print "----------------- DATA --------------------"
print ">>>", data
print open(data[7:]).read()
if graphdata:
print "----------------- GRAPHDATA --------------------"
for x in graphdata:
print ">>>", x
print open(x[7:]).read()
print "----------------- Query -------------------"
print ">>>", query
print open(query[7:]).read()
if resfile:
print "----------------- Res -------------------"
print ">>>", resfile
print open(resfile[7:]).read()
try:
pq = parseQuery(open(query[7:]).read())
print "----------------- Parsed ------------------"
pprintAlgebra(translateQuery(pq, base=urljoin(query, '.')))
except:
print "(parser error)"
print decodeStringEscape(unicode(e))
import pdb
pdb.post_mortem(sys.exc_info()[2])
# pdb.set_trace()
# nose.tools.set_trace()
raise
def __init__(self, res):
Result.__init__(self, res["type_"])
self.vars = res.get("vars_")
self.bindings = res.get("bindings")
self.askAnswer = res.get("askAnswer")
self.graph = res.get("graph")
def triples(self, spo, context=None):
"""
- tuple **(s, o, p)**
the triple used as filter for the SPARQL select.
(None, None, None) means anything.
- context **context**
the graph effectively calling this method.
Returns a tuple of triples executing essentially a SPARQL like
SELECT ?subj ?pred ?obj WHERE { ?subj ?pred ?obj }
**context** may include three parameter
to refine the underlying query:
* LIMIT: an integer to limit the number of results
* OFFSET: an integer to enable paging of results
* ORDERBY: an instance of Variable('s'), Variable('o') or Variable('p')
or, by default, the first 'None' from the given triple
.. warning::
- Using LIMIT or OFFSET automatically include ORDERBY otherwise this is
because the results are retrieved in a not deterministic way (depends on
the walking path on the graph)
- Using OFFSET without defining LIMIT will discard the first OFFSET - 1
results
``
a_graph.LIMIT = limit
a_graph.OFFSET = offset
triple_generator = a_graph.triples(mytriple):
#do something
#Removes LIMIT and OFFSET if not required for the next triple() calls
del a_graph.LIMIT
del a_graph.OFFSET
``
"""
s, p, o = spo
vars = []
if not s:
s = Variable('s')
vars.append(s)
if not p:
p = Variable('p')
vars.append(p)
if not o:
o = Variable('o')
vars.append(o)
if vars:
v = ' '.join([term.n3() for term in vars])
verb = 'SELECT %s '%v
else:
verb = 'ASK'
nts = self.node_to_sparql
query = "%s { %s %s %s }" % (verb, nts(s), nts(p), nts(o))
# The ORDER BY is necessary
if hasattr(context, LIMIT) or hasattr(context, OFFSET) \
or hasattr(context, ORDERBY):
var = None
if isinstance(s, Variable):
var = s
elif isinstance(p, Variable):
var = p
elif isinstance(o, Variable):
var = o
elif hasattr(context, ORDERBY) \
and isinstance(getattr(context, ORDERBY), Variable):
var = getattr(context, ORDERBY)
query = query + ' %s %s' % (ORDERBY, var.n3())
try:
query = query + ' LIMIT %s' % int(getattr(context, LIMIT))
except (ValueError, TypeError, AttributeError):
pass
try:
query = query + ' OFFSET %s' % int(getattr(context, OFFSET))
except (ValueError, TypeError, AttributeError):
pass
self.resetQuery()
if self._is_contextual(context):
self.addParameter("default-graph-uri", context.identifier)
self.timeout = self._timeout
self.setQuery(query)
with contextlib.closing(SPARQLWrapper.query(self).response) as res:
result = Result.parse(res, format=self.returnFormat)
if vars:
for row in result:
yield (row.get(s, s),
row.get(p, p),
row.get(o, o)), None # why is the context here not the passed in graph 'context'?
else:
if result.askAnswer:
yield (s,p,o), None
