trustgraph-base 2.2.16__tar.gz → 2.2.17__tar.gz

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 2.2.16
+Version: 2.2.17
 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

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph/api/flow.py

@@ -1122,6 +1122,45 @@ class FlowInstance:
             
         return result
 
+    def sparql_query(
+            self, query, user="trustgraph", collection="default",
+            limit=10000
+    ):
+        """
+        Execute a SPARQL query against the knowledge graph.
+
+        Args:
+            query: SPARQL 1.1 query string
+            user: User/keyspace identifier (default: "trustgraph")
+            collection: Collection identifier (default: "default")
+            limit: Safety limit on results (default: 10000)
+
+        Returns:
+            dict with query results. Structure depends on query type:
+            - SELECT: {"query-type": "select", "variables": [...], "bindings": [...]}
+            - ASK: {"query-type": "ask", "ask-result": bool}
+            - CONSTRUCT/DESCRIBE: {"query-type": "construct", "triples": [...]}
+
+        Raises:
+            ProtocolException: If an error occurs
+        """
+
+        input = {
+            "query": query,
+            "user": user,
+            "collection": collection,
+            "limit": limit,
+        }
+
+        response = self.request("service/sparql", input)
+
+        if "error" in response and response["error"]:
+            error_type = response["error"].get("type", "unknown")
+            error_message = response["error"].get("message", "Unknown error")
+            raise ProtocolException(f"{error_type}: {error_message}")
+
+        return response
+
     def nlp_query(self, question, max_results=100):
         """
         Convert a natural language question to a GraphQL query.

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph/api/socket_client.py

@@ -812,6 +812,31 @@ class SocketFlowInstance:
             else:
                 yield response
 
+    def sparql_query_stream(
+        self,
+        query: str,
+        user: str = "trustgraph",
+        collection: str = "default",
+        limit: int = 10000,
+        batch_size: int = 20,
+        **kwargs: Any
+    ) -> Iterator[Dict[str, Any]]:
+        """Execute a SPARQL query with streaming batches."""
+        request = {
+            "query": query,
+            "user": user,
+            "collection": collection,
+            "limit": limit,
+            "streaming": True,
+            "batch-size": batch_size,
+        }
+        request.update(kwargs)
+
+        for response in self.client._send_request_sync(
+            "sparql", self.flow_id, request, streaming_raw=True
+        ):
+            yield response
+
     def rows_query(
         self,
         query: str,

trustgraph_base-2.2.17/trustgraph/base_version.py

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

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph/messaging/__init__.py

@@ -27,6 +27,7 @@ from .translators.nlp_query import QuestionToStructuredQueryRequestTranslator, Q
 from .translators.structured_query import StructuredQueryRequestTranslator, StructuredQueryResponseTranslator
 from .translators.diagnosis import StructuredDataDiagnosisRequestTranslator, StructuredDataDiagnosisResponseTranslator
 from .translators.collection import CollectionManagementRequestTranslator, CollectionManagementResponseTranslator
+from .translators.sparql_query import SparqlQueryRequestTranslator, SparqlQueryResponseTranslator
 
 # Register all service translators
 TranslatorRegistry.register_service(
@@ -149,6 +150,12 @@ TranslatorRegistry.register_service(
     CollectionManagementResponseTranslator()
 )
 
+TranslatorRegistry.register_service(
+    "sparql-query",
+    SparqlQueryRequestTranslator(),
+    SparqlQueryResponseTranslator()
+)
+
 # Register single-direction translators for document loading
 TranslatorRegistry.register_request("document", DocumentTranslator())
 TranslatorRegistry.register_request("text-document", TextDocumentTranslator())

trustgraph_base-2.2.17/trustgraph/messaging/translators/sparql_query.py

@@ -0,0 +1,115 @@
+from typing import Dict, Any, Tuple
+from ...schema import (
+    SparqlQueryRequest, SparqlQueryResponse, SparqlBinding,
+    Error, Term, Triple, IRI, LITERAL, BLANK,
+)
+from .base import MessageTranslator
+from .primitives import TermTranslator, TripleTranslator
+
+
+class SparqlQueryRequestTranslator(MessageTranslator):
+    """Translator for SparqlQueryRequest schema objects."""
+
+    def decode(self, data: Dict[str, Any]) -> SparqlQueryRequest:
+        return SparqlQueryRequest(
+            user=data.get("user", "trustgraph"),
+            collection=data.get("collection", "default"),
+            query=data.get("query", ""),
+            limit=int(data.get("limit", 10000)),
+            streaming=data.get("streaming", False),
+            batch_size=int(data.get("batch-size", 20)),
+        )
+
+    def encode(self, obj: SparqlQueryRequest) -> Dict[str, Any]:
+        return {
+            "user": obj.user,
+            "collection": obj.collection,
+            "query": obj.query,
+            "limit": obj.limit,
+            "streaming": obj.streaming,
+            "batch-size": obj.batch_size,
+        }
+
+
+class SparqlQueryResponseTranslator(MessageTranslator):
+    """Translator for SparqlQueryResponse schema objects."""
+
+    def __init__(self):
+        self.term_translator = TermTranslator()
+        self.triple_translator = TripleTranslator()
+
+    def decode(self, data: Dict[str, Any]) -> SparqlQueryResponse:
+        raise NotImplementedError(
+            "Response translation to schema not typically needed"
+        )
+
+    def _encode_term(self, v):
+        """Encode a Term, handling both Term objects and dicts from
+        pub/sub deserialization."""
+        if v is None:
+            return None
+        if isinstance(v, dict):
+            # Reconstruct Term from dict (pub/sub deserializes nested
+            # dataclasses as dicts)
+            term = Term(
+                type=v.get("type", ""),
+                iri=v.get("iri", ""),
+                id=v.get("id", ""),
+                value=v.get("value", ""),
+                datatype=v.get("datatype", ""),
+                language=v.get("language", ""),
+            )
+            return self.term_translator.encode(term)
+        return self.term_translator.encode(v)
+
+    def _encode_error(self, error):
+        """Encode an Error, handling both Error objects and dicts."""
+        if isinstance(error, dict):
+            return {
+                "type": error.get("type", ""),
+                "message": error.get("message", ""),
+            }
+        return {
+            "type": error.type,
+            "message": error.message,
+        }
+
+    def encode(self, obj: SparqlQueryResponse) -> Dict[str, Any]:
+        result = {
+            "query-type": obj.query_type,
+        }
+
+        if obj.error:
+            result["error"] = self._encode_error(obj.error)
+
+        if obj.query_type == "select":
+            result["variables"] = obj.variables
+            bindings = []
+            for binding in obj.bindings:
+                # binding may be a SparqlBinding or a dict
+                if isinstance(binding, dict):
+                    values = binding.get("values", [])
+                else:
+                    values = binding.values
+                bindings.append({
+                    "values": [
+                        self._encode_term(v) for v in values
+                    ]
+                })
+            result["bindings"] = bindings
+
+        elif obj.query_type == "ask":
+            result["ask-result"] = obj.ask_result
+
+        elif obj.query_type in ("construct", "describe"):
+            result["triples"] = [
+                self.triple_translator.encode(t)
+                for t in obj.triples
+            ]
+
+        return result
+
+    def encode_with_completion(
+        self, obj: SparqlQueryResponse
+    ) -> Tuple[Dict[str, Any], bool]:
+        return self.encode(obj), obj.is_final

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph/schema/services/__init__.py

@@ -13,4 +13,5 @@ from .rows_query import *
 from .diagnosis import *
 from .collection import *
 from .storage import *
-from .tool_service import *
+from .tool_service import *
+from .sparql_query import *

trustgraph_base-2.2.17/trustgraph/schema/services/sparql_query.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass, field
+
+from ..core.primitives import Error, Term, Triple
+from ..core.topic import queue
+
+############################################################################
+
+# SPARQL query
+
+@dataclass
+class SparqlBinding:
+    """A single row of SPARQL SELECT results.
+    Values are ordered to match the variables list in SparqlQueryResponse.
+    """
+    values: list[Term | None] = field(default_factory=list)
+
+@dataclass
+class SparqlQueryRequest:
+    user: str = ""
+    collection: str = ""
+    query: str = ""           # SPARQL query string
+    limit: int = 10000        # Safety limit on results
+    streaming: bool = False   # Enable streaming mode
+    batch_size: int = 20      # Bindings per batch in streaming mode
+
+@dataclass
+class SparqlQueryResponse:
+    error: Error | None = None
+    query_type: str = ""      # "select", "ask", "construct", "describe"
+
+    # For SELECT queries
+    variables: list[str] = field(default_factory=list)
+    bindings: list[SparqlBinding] = field(default_factory=list)
+
+    # For ASK queries
+    ask_result: bool = False
+
+    # For CONSTRUCT/DESCRIBE queries
+    triples: list[Triple] = field(default_factory=list)
+
+    is_final: bool = True     # False for intermediate batches in streaming
+
+sparql_query_request_queue = queue('sparql-query', cls='request')
+sparql_query_response_queue = queue('sparql-query', cls='response')

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 2.2.16
+Version: 2.2.17
 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

{trustgraph_base-2.2.16 → trustgraph_base-2.2.17}/trustgraph_base.egg-info/SOURCES.txt

@@ -108,6 +108,7 @@ trustgraph/messaging/translators/primitives.py
 trustgraph/messaging/translators/prompt.py
 trustgraph/messaging/translators/retrieval.py
 trustgraph/messaging/translators/rows_query.py
+trustgraph/messaging/translators/sparql_query.py
 trustgraph/messaging/translators/structured_query.py
 trustgraph/messaging/translators/text_completion.py
 trustgraph/messaging/translators/tool.py
@@ -149,6 +150,7 @@ trustgraph/schema/services/prompt.py
 trustgraph/schema/services/query.py
 trustgraph/schema/services/retrieval.py
 trustgraph/schema/services/rows_query.py
+trustgraph/schema/services/sparql_query.py
 trustgraph/schema/services/storage.py
 trustgraph/schema/services/structured_query.py
 trustgraph/schema/services/tool_service.py

trustgraph_base-2.2.16/trustgraph/base_version.py

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