def construct(self, sparql, format):
out_format = format
if format in ['json', 'dict']:
out_format = 'ntriples'
ctype = self._get_mimetype(out_format)
params = urlencode({
'query': sparql,
'queryLn': 'SPARQL',
'infer': 'false'
})
resp, content = self._http.request('%s/repositories/%s?%s' %
(self._url, self._name, params),
'GET',
headers={'Accept': ctype})
if resp['status'] != '200':
raise QueryError(content)
# Allegro Graph returns status 200 when parsing failed
if content.startswith('Server error:'):
raise QueryError(content[14:])
result = StringIO(content)
if format == 'json':
result = ntriples_to_json(result)
elif format == 'dict':
result = ntriples_to_dict(result)
return result
def construct(self, sparql, fmt):
out_format = fmt
if fmt in ('json', 'dict'):
out_format = 'ntriples'
ctype = self._get_mimetype(out_format)
params = urlencode({
'query': sparql,
'queryLn': 'SPARQL',
'infer': 'false'
})
# content: bytes
resp = requests.get(f'{self._url}/repositories/{self._name}?{params}',
headers={'Accept': ctype})
if resp.status_code != 200:
raise QueryError(resp.status_code)
# Allegro Graph returns status 200 when parsing failed
if resp.text.startswith('Server error:'):
raise QueryError(resp[14:])
if fmt == 'json':
return ntriples_to_json(BytesIO(to_bytes(resp)))
elif fmt == 'dict':
return ntriples_to_dict(BytesIO(to_bytes(resp)))
else:
return StringIO(resp.text)
def test_uri_object(self):
nt = b'<uri:a> <uri:b> <uri:c> .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertEqual(
data, {u'uri:a': {
u'uri:b': [{
'value': 'uri:c',
'type': 'uri'
}]
}})
self.assertEqual(nt, dict_to_ntriples(data).read())
def test_bnode_subject(self):
nt = '_:a <uri:b> _:c .\n'
data = ntriples_to_dict(StringIO(nt))
self.assertEquals(
data, {u'_:a': {
u'uri:b': [{
'value': u'c',
'type': u'bnode'
}]
}})
self.assertEquals(nt, dict_to_ntriples(data).read())
def test_bnode_subject(self):
nt = b'_:a <uri:b> _:c .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertSequenceEqual(
to_tuple({ANY: {
'uri:b': [{
'value': ANY,
'type': 'bnode'
}]
}}), to_tuple(data))
self.assertEqual(nt, dict_to_ntriples(data, 'a', 'c').read())
def test_bnode_object(self):
nt = b'<uri:a> <uri:b> _:c .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertDictEqual(
{'uri:a': {
'uri:b': [{
'value': mock.ANY,
'type': 'bnode'
}]
}}, data)
self.assertEqual(nt, dict_to_ntriples(data, 'c').read())
def test_literal_object(self):
nt = '<uri:a> <uri:b> "foo" .\n'
data = ntriples_to_dict(StringIO(nt))
self.assertEquals(
data,
{u'uri:a': {
u'uri:b': [{
'value': u'foo',
'type': u'literal'
}]
}})
self.assertEquals(nt, dict_to_ntriples(data).read())
def test_literal_value_newline_tab_escape(self):
nt = '<uri:a> <uri:b> "\\n\\tHello!\\n" .\n'
data = ntriples_to_dict(StringIO(nt))
self.assertEquals(data, {
u'uri:a': {
u'uri:b': [{
'value': u'\n\tHello!\n',
'type': u'literal'
}]
}
})
self.assertEquals(nt, dict_to_ntriples(data).read())
def test_literal_value_quote_escape(self):
nt = '<uri:a> <uri:b> "I say \\"Hello\\"." .\n'
data = ntriples_to_dict(StringIO(nt))
self.assertEquals(
data, {
u'uri:a': {
u'uri:b': [{
'value': u'I say "Hello".',
'type': u'literal'
}]
}
})
self.assertEquals(nt, dict_to_ntriples(data).read())
def test_literal_value_backslash_escape(self):
nt = '<uri:a> <uri:b> "c:\\\\temp\\\\foo.txt" .\n'
data = ntriples_to_dict(StringIO(nt))
self.assertEquals(
data, {
u'uri:a': {
u'uri:b': [{
'value': u'c:\\temp\\foo.txt',
'type': u'literal'
}]
}
})
self.assertEquals(nt, dict_to_ntriples(data).read())
def test_literal_value_backslash_escape(self):
nt = b'<uri:a> <uri:b> "c:\\\\temp\\\\foo.txt" .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertDictEqual(
{
'uri:a': {
'uri:b': [{
'value': 'c:\\temp\\foo.txt',
'type': 'literal'
}]
}
}, data)
self.assertEqual(nt, dict_to_ntriples(data).read())
def construct(self, query, fmt):
result = super(AllegroTripleStore, self).construct(query, 'rdfxml')
if fmt == 'rdfxml':
return result
result = self._rdfxml_to_ntriples(result)
if fmt == 'ntriples':
return result
elif fmt == 'json':
return ntriples_to_json(result)
elif fmt == 'dict':
return ntriples_to_dict(result)
elif fmt == 'turtle':
return self._ntriples_to_turtle(result)
def test_literal_datatype_object(self):
nt = b'<uri:a> <uri:b> "foo"^^<uri:string> .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertEqual(
{
'uri:a': {
'uri:b': [{
'value': 'foo',
'datatype': 'uri:string',
'type': 'literal'
}]
}
}, data)
self.assertEqual(nt, dict_to_ntriples(data).read())
def test_literal_language_object(self):
nt = b'<uri:a> <uri:b> "foo"@en .\n'
data = ntriples_to_dict(BytesIO(nt))
self.assertEqual(
data, {
u'uri:a': {
u'uri:b': [{
'value': u'foo',
'lang': u'en',
'type': u'literal'
}]
}
})
self.assertEqual(nt, dict_to_ntriples(data).read())
def construct(self, sparql, format):
out_format = format
if format in ['json', 'dict']:
out_format = 'ntriples'
result = self._query(sparql)
if not result.construct:
raise QueryError('CONSTRUCT Query did not return a graph')
result = self._serialize(result.result,
self._rdflib_format(out_format))
if format == 'json':
result = ntriples_to_json(result)
elif format == 'dict':
result = ntriples_to_dict(result)
return result
def construct(self, sparql, format):
out_format = format
if format in ['json', 'dict']:
out_format = 'ntriples'
result = self._query(sparql)
if not result.is_graph():
raise QueryError('CONSTRUCT Query did not return a graph')
m = RDF.Model()
stream = result.as_stream()
if stream is None:
return
result = self._serialize_stream(stream, out_format)
if format == 'json':
result = ntriples_to_json(result)
elif format == 'dict':
result = ntriples_to_dict(result)
return result
def get_dict(self, context_name):
data = self.get_ntriples(context_name)
return ntriples_to_dict(data)