apunkt/trustgraph
1
0
Fork 0
mirror of https://github.com/trustgraph-ai/trustgraph.git synced 2026-07-23 12:11:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Fixing the other graph types to at least pass some tests

Browse source
This commit is contained in:
Cyber MacGeddon 2026-01-27 09:48:28 +00:00
parent de5527c068
commit 4b7e897785
8 changed files with 285 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

54
tests/unit/test_query/test_memgraph_user_collection_query.py
View file

@ -6,7 +6,7 @@ import pytest
from unittest.mock import MagicMock, patch from unittest.mock import MagicMock, patch
from trustgraph.query.triples.memgraph.service import Processor from trustgraph.query.triples.memgraph.service import Processor
from trustgraph.schema import TriplesQueryRequest, Value from trustgraph.schema import TriplesQueryRequest, Term, IRI, LITERAL
class TestMemgraphQueryUserCollectionIsolation: class TestMemgraphQueryUserCollectionIsolation:
@ -24,9 +24,9 @@ class TestMemgraphQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=Value(value="test_object", is_uri=False), o=Term(type=LITERAL, value="test_object"),
limit=1000 limit=1000
) )
@ -65,8 +65,8 @@ class TestMemgraphQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=None, o=None,
limit=1000 limit=1000
) )
@ -105,9 +105,9 @@ class TestMemgraphQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=Value(value="http://example.com/o", is_uri=True), o=Term(type=IRI, iri="http://example.com/o"),
limit=1000 limit=1000
) )
@ -145,7 +145,7 @@ class TestMemgraphQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=1000 limit=1000
@ -185,8 +185,8 @@ class TestMemgraphQueryUserCollectionIsolation:
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=None, s=None,
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=Value(value="literal", is_uri=False), o=Term(type=LITERAL, value="literal"),
limit=1000 limit=1000
) )
@ -225,7 +225,7 @@ class TestMemgraphQueryUserCollectionIsolation:
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=None, s=None,
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=None, o=None,
limit=1000 limit=1000
) )
@ -265,7 +265,7 @@ class TestMemgraphQueryUserCollectionIsolation:
collection="test_collection", collection="test_collection",
s=None, s=None,
p=None, p=None,
o=Value(value="test_value", is_uri=False), o=Term(type=LITERAL, value="test_value"),
limit=1000 limit=1000
) )
@ -355,7 +355,7 @@ class TestMemgraphQueryUserCollectionIsolation:
# Query without user/collection fields # Query without user/collection fields
query = TriplesQueryRequest( query = TriplesQueryRequest(
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=1000 limit=1000
@ -385,7 +385,7 @@ class TestMemgraphQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=1000 limit=1000
@ -416,17 +416,17 @@ class TestMemgraphQueryUserCollectionIsolation:
assert len(result) == 2 assert len(result) == 2
# First triple (literal object) # First triple (literal object)
assert result[0].s.value == "http://example.com/s" assert result[0].s.iri == "http://example.com/s"
assert result[0].s.is_uri == True assert result[0].s.type == IRI
assert result[0].p.value == "http://example.com/p1" assert result[0].p.iri == "http://example.com/p1"
assert result[0].p.is_uri == True assert result[0].p.type == IRI
assert result[0].o.value == "literal_value" assert result[0].o.value == "literal_value"
assert result[0].o.is_uri == False assert result[0].o.type == LITERAL
# Second triple (URI object) # Second triple (URI object)
assert result[1].s.value == "http://example.com/s" assert result[1].s.iri == "http://example.com/s"
assert result[1].s.is_uri == True assert result[1].s.type == IRI
assert result[1].p.value == "http://example.com/p2" assert result[1].p.iri == "http://example.com/p2"
assert result[1].p.is_uri == True assert result[1].p.type == IRI
assert result[1].o.value == "http://example.com/o" assert result[1].o.iri == "http://example.com/o"
assert result[1].o.is_uri == True assert result[1].o.type == IRI

52
tests/unit/test_query/test_neo4j_user_collection_query.py
View file

@ -24,9 +24,9 @@ class TestNeo4jQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=Value(value="test_object", is_uri=False), o=Term(type=LITERAL, value="test_object"),
limit=10 limit=10
) )
@ -65,8 +65,8 @@ class TestNeo4jQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=None, o=None,
limit=10 limit=10
) )
@ -123,9 +123,9 @@ class TestNeo4jQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=Value(value="http://example.com/o", is_uri=True), o=Term(type=IRI, iri="http://example.com/o"),
limit=10 limit=10
) )
@ -163,7 +163,7 @@ class TestNeo4jQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=10 limit=10
@ -203,8 +203,8 @@ class TestNeo4jQueryUserCollectionIsolation:
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=None, s=None,
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=Value(value="literal", is_uri=False), o=Term(type=LITERAL, value="literal"),
limit=10 limit=10
) )
@ -243,7 +243,7 @@ class TestNeo4jQueryUserCollectionIsolation:
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=None, s=None,
p=Value(value="http://example.com/p", is_uri=True), p=Term(type=IRI, iri="http://example.com/p"),
o=None, o=None,
limit=10 limit=10
) )
@ -283,7 +283,7 @@ class TestNeo4jQueryUserCollectionIsolation:
collection="test_collection", collection="test_collection",
s=None, s=None,
p=None, p=None,
o=Value(value="test_value", is_uri=False), o=Term(type=LITERAL, value="test_value"),
limit=10 limit=10
) )
@ -373,7 +373,7 @@ class TestNeo4jQueryUserCollectionIsolation:
# Query without user/collection fields # Query without user/collection fields
query = TriplesQueryRequest( query = TriplesQueryRequest(
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=10 limit=10
@ -403,7 +403,7 @@ class TestNeo4jQueryUserCollectionIsolation:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user="test_user", user="test_user",
collection="test_collection", collection="test_collection",
s=Value(value="http://example.com/s", is_uri=True), s=Term(type=IRI, iri="http://example.com/s"),
p=None, p=None,
o=None, o=None,
limit=10 limit=10
@ -434,17 +434,17 @@ class TestNeo4jQueryUserCollectionIsolation:
assert len(result) == 2 assert len(result) == 2
# First triple (literal object) # First triple (literal object)
assert result[0].s.value == "http://example.com/s" assert result[0].s.iri == "http://example.com/s"
assert result[0].s.is_uri == True assert result[0].s.type == IRI
assert result[0].p.value == "http://example.com/p1" assert result[0].p.iri == "http://example.com/p1"
assert result[0].p.is_uri == True assert result[0].p.type == IRI
assert result[0].o.value == "literal_value" assert result[0].o.value == "literal_value"
assert result[0].o.is_uri == False assert result[0].o.type == LITERAL
# Second triple (URI object) # Second triple (URI object)
assert result[1].s.value == "http://example.com/s" assert result[1].s.iri == "http://example.com/s"
assert result[1].s.is_uri == True assert result[1].s.type == IRI
assert result[1].p.value == "http://example.com/p2" assert result[1].p.iri == "http://example.com/p2"
assert result[1].p.is_uri == True assert result[1].p.type == IRI
assert result[1].o.value == "http://example.com/o" assert result[1].o.iri == "http://example.com/o"
assert result[1].o.is_uri == True assert result[1].o.type == IRI

66
tests/unit/test_query/test_triples_falkordb_query.py
View file

@ -25,50 +25,50 @@ class TestFalkorDBQueryProcessor:
def test_create_value_with_http_uri(self, processor): def test_create_value_with_http_uri(self, processor):
"""Test create_value with HTTP URI""" """Test create_value with HTTP URI"""
result = processor.create_value("http://example.com/resource") result = processor.create_value("http://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http://example.com/resource" assert result.iri == "http://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_https_uri(self, processor): def test_create_value_with_https_uri(self, processor):
"""Test create_value with HTTPS URI""" """Test create_value with HTTPS URI"""
result = processor.create_value("https://example.com/resource") result = processor.create_value("https://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "https://example.com/resource" assert result.iri == "https://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_literal(self, processor): def test_create_value_with_literal(self, processor):
"""Test create_value with literal value""" """Test create_value with literal value"""
result = processor.create_value("just a literal string") result = processor.create_value("just a literal string")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "just a literal string" assert result.value == "just a literal string"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_empty_string(self, processor): def test_create_value_with_empty_string(self, processor):
"""Test create_value with empty string""" """Test create_value with empty string"""
result = processor.create_value("") result = processor.create_value("")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "" assert result.value == ""
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_partial_uri(self, processor): def test_create_value_with_partial_uri(self, processor):
"""Test create_value with string that looks like URI but isn't complete""" """Test create_value with string that looks like URI but isn't complete"""
result = processor.create_value("http") result = processor.create_value("http")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http" assert result.value == "http"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_ftp_uri(self, processor): def test_create_value_with_ftp_uri(self, processor):
"""Test create_value with FTP URI (should not be detected as URI)""" """Test create_value with FTP URI (should not be detected as URI)"""
result = processor.create_value("ftp://example.com/file") result = processor.create_value("ftp://example.com/file")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "ftp://example.com/file" assert result.value == "ftp://example.com/file"
assert result.is_uri is False assert result.type == LITERAL
@patch('trustgraph.query.triples.falkordb.service.FalkorDB') @patch('trustgraph.query.triples.falkordb.service.FalkorDB')
def test_processor_initialization_with_defaults(self, mock_falkordb): def test_processor_initialization_with_defaults(self, mock_falkordb):
@ -125,9 +125,9 @@ class TestFalkorDBQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -166,8 +166,8 @@ class TestFalkorDBQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=None, o=None,
limit=100 limit=100
) )
@ -211,9 +211,9 @@ class TestFalkorDBQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -256,7 +256,7 @@ class TestFalkorDBQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=None, o=None,
limit=100 limit=100
@ -302,8 +302,8 @@ class TestFalkorDBQueryProcessor:
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=None, s=None,
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -347,7 +347,7 @@ class TestFalkorDBQueryProcessor:
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=None, s=None,
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=None, o=None,
limit=100 limit=100
) )
@ -393,7 +393,7 @@ class TestFalkorDBQueryProcessor:
collection='test_collection', collection='test_collection',
s=None, s=None,
p=None, p=None,
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -476,7 +476,7 @@ class TestFalkorDBQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=None, o=None,
limit=100 limit=100

66
tests/unit/test_query/test_triples_memgraph_query.py
View file

@ -25,50 +25,50 @@ class TestMemgraphQueryProcessor:
def test_create_value_with_http_uri(self, processor): def test_create_value_with_http_uri(self, processor):
"""Test create_value with HTTP URI""" """Test create_value with HTTP URI"""
result = processor.create_value("http://example.com/resource") result = processor.create_value("http://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http://example.com/resource" assert result.iri == "http://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_https_uri(self, processor): def test_create_value_with_https_uri(self, processor):
"""Test create_value with HTTPS URI""" """Test create_value with HTTPS URI"""
result = processor.create_value("https://example.com/resource") result = processor.create_value("https://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "https://example.com/resource" assert result.iri == "https://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_literal(self, processor): def test_create_value_with_literal(self, processor):
"""Test create_value with literal value""" """Test create_value with literal value"""
result = processor.create_value("just a literal string") result = processor.create_value("just a literal string")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "just a literal string" assert result.value == "just a literal string"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_empty_string(self, processor): def test_create_value_with_empty_string(self, processor):
"""Test create_value with empty string""" """Test create_value with empty string"""
result = processor.create_value("") result = processor.create_value("")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "" assert result.value == ""
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_partial_uri(self, processor): def test_create_value_with_partial_uri(self, processor):
"""Test create_value with string that looks like URI but isn't complete""" """Test create_value with string that looks like URI but isn't complete"""
result = processor.create_value("http") result = processor.create_value("http")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http" assert result.value == "http"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_ftp_uri(self, processor): def test_create_value_with_ftp_uri(self, processor):
"""Test create_value with FTP URI (should not be detected as URI)""" """Test create_value with FTP URI (should not be detected as URI)"""
result = processor.create_value("ftp://example.com/file") result = processor.create_value("ftp://example.com/file")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "ftp://example.com/file" assert result.value == "ftp://example.com/file"
assert result.is_uri is False assert result.type == LITERAL
@patch('trustgraph.query.triples.memgraph.service.GraphDatabase') @patch('trustgraph.query.triples.memgraph.service.GraphDatabase')
def test_processor_initialization_with_defaults(self, mock_graph_db): def test_processor_initialization_with_defaults(self, mock_graph_db):
@ -124,9 +124,9 @@ class TestMemgraphQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -166,8 +166,8 @@ class TestMemgraphQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=None, o=None,
limit=100 limit=100
) )
@ -212,9 +212,9 @@ class TestMemgraphQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -258,7 +258,7 @@ class TestMemgraphQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=None, o=None,
limit=100 limit=100
@ -305,8 +305,8 @@ class TestMemgraphQueryProcessor:
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=None, s=None,
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -351,7 +351,7 @@ class TestMemgraphQueryProcessor:
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=None, s=None,
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=None, o=None,
limit=100 limit=100
) )
@ -398,7 +398,7 @@ class TestMemgraphQueryProcessor:
collection='test_collection', collection='test_collection',
s=None, s=None,
p=None, p=None,
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -480,7 +480,7 @@ class TestMemgraphQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=None, o=None,
limit=100 limit=100

54
tests/unit/test_query/test_triples_neo4j_query.py
View file

@ -25,50 +25,50 @@ class TestNeo4jQueryProcessor:
def test_create_value_with_http_uri(self, processor): def test_create_value_with_http_uri(self, processor):
"""Test create_value with HTTP URI""" """Test create_value with HTTP URI"""
result = processor.create_value("http://example.com/resource") result = processor.create_value("http://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http://example.com/resource" assert result.iri == "http://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_https_uri(self, processor): def test_create_value_with_https_uri(self, processor):
"""Test create_value with HTTPS URI""" """Test create_value with HTTPS URI"""
result = processor.create_value("https://example.com/resource") result = processor.create_value("https://example.com/resource")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "https://example.com/resource" assert result.iri == "https://example.com/resource"
assert result.is_uri is True assert result.type == IRI
def test_create_value_with_literal(self, processor): def test_create_value_with_literal(self, processor):
"""Test create_value with literal value""" """Test create_value with literal value"""
result = processor.create_value("just a literal string") result = processor.create_value("just a literal string")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "just a literal string" assert result.value == "just a literal string"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_empty_string(self, processor): def test_create_value_with_empty_string(self, processor):
"""Test create_value with empty string""" """Test create_value with empty string"""
result = processor.create_value("") result = processor.create_value("")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "" assert result.value == ""
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_partial_uri(self, processor): def test_create_value_with_partial_uri(self, processor):
"""Test create_value with string that looks like URI but isn't complete""" """Test create_value with string that looks like URI but isn't complete"""
result = processor.create_value("http") result = processor.create_value("http")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "http" assert result.value == "http"
assert result.is_uri is False assert result.type == LITERAL
def test_create_value_with_ftp_uri(self, processor): def test_create_value_with_ftp_uri(self, processor):
"""Test create_value with FTP URI (should not be detected as URI)""" """Test create_value with FTP URI (should not be detected as URI)"""
result = processor.create_value("ftp://example.com/file") result = processor.create_value("ftp://example.com/file")
assert isinstance(result, Value) assert isinstance(result, Term)
assert result.value == "ftp://example.com/file" assert result.value == "ftp://example.com/file"
assert result.is_uri is False assert result.type == LITERAL
@patch('trustgraph.query.triples.neo4j.service.GraphDatabase') @patch('trustgraph.query.triples.neo4j.service.GraphDatabase')
def test_processor_initialization_with_defaults(self, mock_graph_db): def test_processor_initialization_with_defaults(self, mock_graph_db):
@ -124,9 +124,9 @@ class TestNeo4jQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=Value(value="literal object", is_uri=False), o=Term(type=LITERAL, value="literal object"),
limit=100 limit=100
) )
@ -166,8 +166,8 @@ class TestNeo4jQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=Value(value="http://example.com/predicate", is_uri=True), p=Term(type=IRI, iri="http://example.com/predicate"),
o=None, o=None,
limit=100 limit=100
) )
@ -250,12 +250,12 @@ class TestNeo4jQueryProcessor:
query = TriplesQueryRequest( query = TriplesQueryRequest(
user='test_user', user='test_user',
collection='test_collection', collection='test_collection',
s=Value(value="http://example.com/subject", is_uri=True), s=Term(type=IRI, iri="http://example.com/subject"),
p=None, p=None,
o=None, o=None,
limit=100 limit=100
) )
# Should raise the exception # Should raise the exception
with pytest.raises(Exception, match="Database connection failed"): with pytest.raises(Exception, match="Database connection failed"):
await processor.query_triples(query) await processor.query_triples(query)

94
trustgraph-flow/trustgraph/query/triples/falkordb/service.py
View file

@ -10,12 +10,24 @@ import logging
from falkordb import FalkorDB from falkordb import FalkorDB
from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error
from .... schema import Value, Triple from .... schema import Term, Triple, IRI, LITERAL
from .... base import TriplesQueryService from .... base import TriplesQueryService
# Module logger # Module logger
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
def get_term_value(term):
"""Extract the string value from a Term"""
if term is None:
return None
if term.type == IRI:
return term.iri
elif term.type == LITERAL:
return term.value
else:
return term.id or term.value
default_ident = "triples-query" default_ident = "triples-query"
default_graph_url = 'falkor://falkordb:6379' default_graph_url = 'falkor://falkordb:6379'
@ -42,9 +54,9 @@ class Processor(TriplesQueryService):
def create_value(self, ent): def create_value(self, ent):
if ent.startswith("http://") or ent.startswith("https://"): if ent.startswith("http://") or ent.startswith("https://"):
return Value(value=ent, is_uri=True) return Term(type=IRI, iri=ent)
else: else:
return Value(value=ent, is_uri=False) return Term(type=LITERAL, value=ent)
async def query_triples(self, query): async def query_triples(self, query):
@ -63,28 +75,28 @@ class Processor(TriplesQueryService):
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"rel": query.p.value, "rel": get_term_value(query.p),
"value": query.o.value, "value": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
records = self.io.query( records = self.io.query(
"MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node {uri: $uri}) " "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node {uri: $uri}) "
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"rel": query.p.value, "rel": get_term_value(query.p),
"uri": query.o.value, "uri": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -95,26 +107,26 @@ class Processor(TriplesQueryService):
"RETURN dest.value as dest " "RETURN dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"rel": query.p.value, "rel": get_term_value(query.p),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, rec[0])) triples.append((get_term_value(query.s), get_term_value(query.p), rec[0]))
records = self.io.query( records = self.io.query(
"MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) " "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) "
"RETURN dest.uri as dest " "RETURN dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"rel": query.p.value, "rel": get_term_value(query.p),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, rec[0])) triples.append((get_term_value(query.s), get_term_value(query.p), rec[0]))
else: else:
@ -127,26 +139,26 @@ class Processor(TriplesQueryService):
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"value": query.o.value, "value": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, rec[0], query.o.value)) triples.append((get_term_value(query.s), rec[0], get_term_value(query.o)))
records = self.io.query( records = self.io.query(
"MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node {uri: $uri}) " "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node {uri: $uri}) "
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
"uri": query.o.value, "uri": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, rec[0], query.o.value)) triples.append((get_term_value(query.s), rec[0], get_term_value(query.o)))
else: else:
@ -157,24 +169,24 @@ class Processor(TriplesQueryService):
"RETURN rel.uri as rel, dest.value as dest " "RETURN rel.uri as rel, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, rec[0], rec[1])) triples.append((get_term_value(query.s), rec[0], rec[1]))
records = self.io.query( records = self.io.query(
"MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) " "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) "
"RETURN rel.uri as rel, dest.uri as dest " "RETURN rel.uri as rel, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"src": query.s.value, "src": get_term_value(query.s),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((query.s.value, rec[0], rec[1])) triples.append((get_term_value(query.s), rec[0], rec[1]))
else: else:
@ -190,26 +202,26 @@ class Processor(TriplesQueryService):
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"uri": query.p.value, "uri": get_term_value(query.p),
"value": query.o.value, "value": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], query.p.value, query.o.value)) triples.append((rec[0], get_term_value(query.p), get_term_value(query.o)))
records = self.io.query( records = self.io.query(
"MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node {uri: $dest}) " "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node {uri: $dest}) "
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"uri": query.p.value, "uri": get_term_value(query.p),
"dest": query.o.value, "dest": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], query.p.value, query.o.value)) triples.append((rec[0], get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -220,24 +232,24 @@ class Processor(TriplesQueryService):
"RETURN src.uri as src, dest.value as dest " "RETURN src.uri as src, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"uri": query.p.value, "uri": get_term_value(query.p),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], query.p.value, rec[1])) triples.append((rec[0], get_term_value(query.p), rec[1]))
records = self.io.query( records = self.io.query(
"MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node) " "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node) "
"RETURN src.uri as src, dest.uri as dest " "RETURN src.uri as src, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"uri": query.p.value, "uri": get_term_value(query.p),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], query.p.value, rec[1])) triples.append((rec[0], get_term_value(query.p), rec[1]))
else: else:
@ -250,24 +262,24 @@ class Processor(TriplesQueryService):
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"value": query.o.value, "value": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], rec[1], query.o.value)) triples.append((rec[0], rec[1], get_term_value(query.o)))
records = self.io.query( records = self.io.query(
"MATCH (src:Node)-[rel:Rel]->(dest:Node {uri: $uri}) " "MATCH (src:Node)-[rel:Rel]->(dest:Node {uri: $uri}) "
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
params={ params={
"uri": query.o.value, "uri": get_term_value(query.o),
}, },
).result_set ).result_set
for rec in records: for rec in records:
triples.append((rec[0], rec[1], query.o.value)) triples.append((rec[0], rec[1], get_term_value(query.o)))
else: else:

74
trustgraph-flow/trustgraph/query/triples/memgraph/service.py
View file

@ -10,12 +10,24 @@ import logging
from neo4j import GraphDatabase from neo4j import GraphDatabase
from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error
from .... schema import Value, Triple from .... schema import Term, Triple, IRI, LITERAL
from .... base import TriplesQueryService from .... base import TriplesQueryService
# Module logger # Module logger
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
def get_term_value(term):
"""Extract the string value from a Term"""
if term is None:
return None
if term.type == IRI:
return term.iri
elif term.type == LITERAL:
return term.value
else:
return term.id or term.value
default_ident = "triples-query" default_ident = "triples-query"
default_graph_host = 'bolt://memgraph:7687' default_graph_host = 'bolt://memgraph:7687'
@ -47,9 +59,9 @@ class Processor(TriplesQueryService):
def create_value(self, ent): def create_value(self, ent):
if ent.startswith("http://") or ent.startswith("https://"): if ent.startswith("http://") or ent.startswith("https://"):
return Value(value=ent, is_uri=True) return Term(type=IRI, iri=ent)
else: else:
return Value(value=ent, is_uri=False) return Term(type=LITERAL, value=ent)
async def query_triples(self, query): async def query_triples(self, query):
@ -73,13 +85,13 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, value=query.o.value, src=get_term_value(query.s), rel=get_term_value(query.p), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -87,13 +99,13 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, uri=query.o.value, src=get_term_value(query.s), rel=get_term_value(query.p), uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -105,14 +117,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN dest.value as dest " "RETURN dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, src=get_term_value(query.s), rel=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, query.p.value, data["dest"])) triples.append((get_term_value(query.s), get_term_value(query.p), data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -120,14 +132,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN dest.uri as dest " "RETURN dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, src=get_term_value(query.s), rel=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, query.p.value, data["dest"])) triples.append((get_term_value(query.s), get_term_value(query.p), data["dest"]))
else: else:
@ -141,14 +153,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, value=query.o.value, src=get_term_value(query.s), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], query.o.value)) triples.append((get_term_value(query.s), data["rel"], get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -156,14 +168,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, uri=query.o.value, src=get_term_value(query.s), uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], query.o.value)) triples.append((get_term_value(query.s), data["rel"], get_term_value(query.o)))
else: else:
@ -175,14 +187,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN rel.uri as rel, dest.value as dest " "RETURN rel.uri as rel, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, src=get_term_value(query.s),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], data["dest"])) triples.append((get_term_value(query.s), data["rel"], data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -190,14 +202,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN rel.uri as rel, dest.uri as dest " "RETURN rel.uri as rel, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, src=get_term_value(query.s),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], data["dest"])) triples.append((get_term_value(query.s), data["rel"], data["dest"]))
else: else:
@ -214,14 +226,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, value=query.o.value, uri=get_term_value(query.p), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, query.o.value)) triples.append((data["src"], get_term_value(query.p), get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -229,14 +241,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $dest, user: $user, collection: $collection}) " "(dest:Node {uri: $dest, user: $user, collection: $collection}) "
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, dest=query.o.value, uri=get_term_value(query.p), dest=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, query.o.value)) triples.append((data["src"], get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -248,14 +260,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN src.uri as src, dest.value as dest " "RETURN src.uri as src, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, uri=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, data["dest"])) triples.append((data["src"], get_term_value(query.p), data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -263,14 +275,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN src.uri as src, dest.uri as dest " "RETURN src.uri as src, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, uri=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, data["dest"])) triples.append((data["src"], get_term_value(query.p), data["dest"]))
else: else:
@ -284,14 +296,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
value=query.o.value, value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], data["rel"], query.o.value)) triples.append((data["src"], data["rel"], get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -299,14 +311,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.o.value, uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], data["rel"], query.o.value)) triples.append((data["src"], data["rel"], get_term_value(query.o)))
else: else:

74
trustgraph-flow/trustgraph/query/triples/neo4j/service.py
View file

@ -10,12 +10,24 @@ import logging
from neo4j import GraphDatabase from neo4j import GraphDatabase
from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error from .... schema import TriplesQueryRequest, TriplesQueryResponse, Error
from .... schema import Value, Triple from .... schema import Term, Triple, IRI, LITERAL
from .... base import TriplesQueryService from .... base import TriplesQueryService
# Module logger # Module logger
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
def get_term_value(term):
"""Extract the string value from a Term"""
if term is None:
return None
if term.type == IRI:
return term.iri
elif term.type == LITERAL:
return term.value
else:
return term.id or term.value
default_ident = "triples-query" default_ident = "triples-query"
default_graph_host = 'bolt://neo4j:7687' default_graph_host = 'bolt://neo4j:7687'
@ -47,9 +59,9 @@ class Processor(TriplesQueryService):
def create_value(self, ent): def create_value(self, ent):
if ent.startswith("http://") or ent.startswith("https://"): if ent.startswith("http://") or ent.startswith("https://"):
return Value(value=ent, is_uri=True) return Term(type=IRI, iri=ent)
else: else:
return Value(value=ent, is_uri=False) return Term(type=LITERAL, value=ent)
async def query_triples(self, query): async def query_triples(self, query):
@ -73,13 +85,13 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, value=query.o.value, src=get_term_value(query.s), rel=get_term_value(query.p), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -87,13 +99,13 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN $src as src " "RETURN $src as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, uri=query.o.value, src=get_term_value(query.s), rel=get_term_value(query.p), uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
triples.append((query.s.value, query.p.value, query.o.value)) triples.append((get_term_value(query.s), get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -105,14 +117,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN dest.value as dest " "RETURN dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, src=get_term_value(query.s), rel=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, query.p.value, data["dest"])) triples.append((get_term_value(query.s), get_term_value(query.p), data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -120,14 +132,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN dest.uri as dest " "RETURN dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, rel=query.p.value, src=get_term_value(query.s), rel=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, query.p.value, data["dest"])) triples.append((get_term_value(query.s), get_term_value(query.p), data["dest"]))
else: else:
@ -141,14 +153,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, value=query.o.value, src=get_term_value(query.s), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], query.o.value)) triples.append((get_term_value(query.s), data["rel"], get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -156,14 +168,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN rel.uri as rel " "RETURN rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, uri=query.o.value, src=get_term_value(query.s), uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], query.o.value)) triples.append((get_term_value(query.s), data["rel"], get_term_value(query.o)))
else: else:
@ -175,14 +187,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN rel.uri as rel, dest.value as dest " "RETURN rel.uri as rel, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, src=get_term_value(query.s),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], data["dest"])) triples.append((get_term_value(query.s), data["rel"], data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {uri: $src, user: $user, collection: $collection})-" "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
@ -190,14 +202,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN rel.uri as rel, dest.uri as dest " "RETURN rel.uri as rel, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
src=query.s.value, src=get_term_value(query.s),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((query.s.value, data["rel"], data["dest"])) triples.append((get_term_value(query.s), data["rel"], data["dest"]))
else: else:
@ -214,14 +226,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, value=query.o.value, uri=get_term_value(query.p), value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, query.o.value)) triples.append((data["src"], get_term_value(query.p), get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -229,14 +241,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $dest, user: $user, collection: $collection}) " "(dest:Node {uri: $dest, user: $user, collection: $collection}) "
"RETURN src.uri as src " "RETURN src.uri as src "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, dest=query.o.value, uri=get_term_value(query.p), dest=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, query.o.value)) triples.append((data["src"], get_term_value(query.p), get_term_value(query.o)))
else: else:
@ -248,14 +260,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {user: $user, collection: $collection}) " "(dest:Literal {user: $user, collection: $collection}) "
"RETURN src.uri as src, dest.value as dest " "RETURN src.uri as src, dest.value as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, uri=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, data["dest"])) triples.append((data["src"], get_term_value(query.p), data["dest"]))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -263,14 +275,14 @@ class Processor(TriplesQueryService):
"(dest:Node {user: $user, collection: $collection}) " "(dest:Node {user: $user, collection: $collection}) "
"RETURN src.uri as src, dest.uri as dest " "RETURN src.uri as src, dest.uri as dest "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.p.value, uri=get_term_value(query.p),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], query.p.value, data["dest"])) triples.append((data["src"], get_term_value(query.p), data["dest"]))
else: else:
@ -284,14 +296,14 @@ class Processor(TriplesQueryService):
"(dest:Literal {value: $value, user: $user, collection: $collection}) " "(dest:Literal {value: $value, user: $user, collection: $collection}) "
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
value=query.o.value, value=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], data["rel"], query.o.value)) triples.append((data["src"], data["rel"], get_term_value(query.o)))
records, summary, keys = self.io.execute_query( records, summary, keys = self.io.execute_query(
"MATCH (src:Node {user: $user, collection: $collection})-" "MATCH (src:Node {user: $user, collection: $collection})-"
@ -299,14 +311,14 @@ class Processor(TriplesQueryService):
"(dest:Node {uri: $uri, user: $user, collection: $collection}) " "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
"RETURN src.uri as src, rel.uri as rel " "RETURN src.uri as src, rel.uri as rel "
"LIMIT " + str(query.limit), "LIMIT " + str(query.limit),
uri=query.o.value, uri=get_term_value(query.o),
user=user, collection=collection, user=user, collection=collection,
database_=self.db, database_=self.db,
) )
for rec in records: for rec in records:
data = rec.data() data = rec.data()
triples.append((data["src"], data["rel"], query.o.value)) triples.append((data["src"], data["rel"], get_term_value(query.o)))
else: else: