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)