trustgraph-flow 1.3.18__tar.gz → 1.4.0__tar.gz

{trustgraph_flow-1.3.18 → trustgraph_flow-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-flow
-Version: 1.3.18
+Version: 1.4.0
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Author-email: "trustgraph.ai" <security@trustgraph.ai>
 Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph
@@ -8,7 +8,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: trustgraph-base<1.4,>=1.3
+Requires-Dist: trustgraph-base<1.5,>=1.4
 Requires-Dist: aiohttp
 Requires-Dist: anthropic
 Requires-Dist: cassandra-driver

{trustgraph_flow-1.3.18 → trustgraph_flow-1.4.0}/pyproject.toml

@@ -10,7 +10,7 @@ description = "TrustGraph provides a means to run a pipeline of flexible AI proc
 readme = "README.md"
 requires-python = ">=3.8"
 dependencies = [
-    "trustgraph-base>=1.3,<1.4",
+    "trustgraph-base>=1.4,<1.5",
     "aiohttp",
     "anthropic",
     "cassandra-driver",

trustgraph_flow-1.4.0/trustgraph/flow_version.py

@@ -0,0 +1 @@
+__version__ = "1.4.0"

{trustgraph_flow-1.3.18 → trustgraph_flow-1.4.0}/trustgraph/query/triples/memgraph/service.py

@@ -55,6 +55,10 @@ class Processor(TriplesQueryService):
 
         try:
 
+            # Extract user and collection, use defaults if not provided
+            user = query.user if query.user else "default"
+            collection = query.collection if query.collection else "default"
+            
             triples = []
 
             if query.s is not None:
@@ -64,10 +68,13 @@ class Processor(TriplesQueryService):
                         # SPO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN $src as src "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, rel=query.p.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -75,10 +82,13 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, query.p.value, query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN $src as src "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, rel=query.p.value, uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -90,10 +100,13 @@ class Processor(TriplesQueryService):
                         # SP
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN dest.value as dest "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, rel=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -102,10 +115,13 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, query.p.value, data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN dest.uri as dest "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, rel=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -120,10 +136,13 @@ class Processor(TriplesQueryService):
                         # SO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -132,10 +151,13 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, data["rel"], query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel "
                             "LIMIT " + str(query.limit),
                             src=query.s.value, uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -148,10 +170,13 @@ class Processor(TriplesQueryService):
                         # S
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel, dest.value as dest "
                             "LIMIT " + str(query.limit),
                             src=query.s.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -160,10 +185,13 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, data["rel"], data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel, dest.uri as dest "
                             "LIMIT " + str(query.limit),
                             src=query.s.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -181,10 +209,13 @@ class Processor(TriplesQueryService):
                         # PO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN src.uri as src "
                             "LIMIT " + str(query.limit),
                             uri=query.p.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -193,10 +224,13 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], query.p.value, query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node {uri: $dest}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $dest, user: $user, collection: $collection}) "
                             "RETURN src.uri as src "
                             "LIMIT " + str(query.limit),
                             uri=query.p.value, dest=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -209,10 +243,13 @@ class Processor(TriplesQueryService):
                         # P
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Literal) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, dest.value as dest "
                             "LIMIT " + str(query.limit),
                             uri=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -221,10 +258,13 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], query.p.value, data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, dest.uri as dest "
                             "LIMIT " + str(query.limit),
                             uri=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -239,10 +279,13 @@ class Processor(TriplesQueryService):
                         # O
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel "
                             "LIMIT " + str(query.limit),
                             value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -251,10 +294,13 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], data["rel"], query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel "
                             "LIMIT " + str(query.limit),
                             uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -267,9 +313,12 @@ class Processor(TriplesQueryService):
                         # *
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Literal) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel, dest.value as dest "
                             "LIMIT " + str(query.limit),
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -278,9 +327,12 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], data["rel"], data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Node) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel, dest.uri as dest "
                             "LIMIT " + str(query.limit),
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 

{trustgraph_flow-1.3.18 → trustgraph_flow-1.4.0}/trustgraph/query/triples/neo4j/service.py

@@ -55,6 +55,10 @@ class Processor(TriplesQueryService):
 
         try:
 
+            # Extract user and collection, use defaults if not provided
+            user = query.user if query.user else "default"
+            collection = query.collection if query.collection else "default"
+            
             triples = []
 
             if query.s is not None:
@@ -64,9 +68,12 @@ class Processor(TriplesQueryService):
                         # SPO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN $src as src",
                             src=query.s.value, rel=query.p.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -74,9 +81,12 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, query.p.value, query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN $src as src",
                             src=query.s.value, rel=query.p.value, uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -88,9 +98,12 @@ class Processor(TriplesQueryService):
                         # SP
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN dest.value as dest",
                             src=query.s.value, rel=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -99,9 +112,12 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, query.p.value, data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $rel, user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN dest.uri as dest",
                             src=query.s.value, rel=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -116,9 +132,12 @@ class Processor(TriplesQueryService):
                         # SO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel",
                             src=query.s.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -127,9 +146,12 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, data["rel"], query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel",
                             src=query.s.value, uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -142,9 +164,12 @@ class Processor(TriplesQueryService):
                         # S
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel, dest.value as dest",
                             src=query.s.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -153,9 +178,12 @@ class Processor(TriplesQueryService):
                             triples.append((query.s.value, data["rel"], data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) "
+                            "MATCH (src:Node {uri: $src, user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN rel.uri as rel, dest.uri as dest",
                             src=query.s.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -173,9 +201,12 @@ class Processor(TriplesQueryService):
                         # PO
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN src.uri as src",
                             uri=query.p.value, value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -184,9 +215,12 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], query.p.value, query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node {uri: $dest}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $dest, user: $user, collection: $collection}) "
                             "RETURN src.uri as src",
                             uri=query.p.value, dest=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -199,9 +233,12 @@ class Processor(TriplesQueryService):
                         # P
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Literal) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, dest.value as dest",
                             uri=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -210,9 +247,12 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], query.p.value, data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel {uri: $uri}]->(dest:Node) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {uri: $uri, user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, dest.uri as dest",
                             uri=query.p.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -227,9 +267,12 @@ class Processor(TriplesQueryService):
                         # O
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Literal {value: $value}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {value: $value, user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel",
                             value=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -238,9 +281,12 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], data["rel"], query.o.value))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Node {uri: $uri}) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {uri: $uri, user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel",
                             uri=query.o.value,
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -253,8 +299,11 @@ class Processor(TriplesQueryService):
                         # *
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Literal) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Literal {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel, dest.value as dest",
+                            user=user, collection=collection,
                             database_=self.db,
                         )
 
@@ -263,8 +312,11 @@ class Processor(TriplesQueryService):
                             triples.append((data["src"], data["rel"], data["dest"]))
 
                         records, summary, keys = self.io.execute_query(
-                            "MATCH (src:Node)-[rel:Rel]->(dest:Node) "
+                            "MATCH (src:Node {user: $user, collection: $collection})-"
+                            "[rel:Rel {user: $user, collection: $collection}]->"
+                            "(dest:Node {user: $user, collection: $collection}) "
                             "RETURN src.uri as src, rel.uri as rel, dest.uri as dest",
+                            user=user, collection=collection,
                             database_=self.db,
                         )