trustgraph-base 1.4.4__tar.gz → 1.4.6__tar.gz

{trustgraph_base-1.4.4 → trustgraph_base-1.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 1.4.4
+Version: 1.4.6
 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-1.4.4 → trustgraph_base-1.4.6}/trustgraph/api/flow.py

@@ -492,12 +492,148 @@ class FlowInstance:
             "service/structured-query",
             input
         )
-        
+
         # Check for system-level error
         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 detect_type(self, sample):
+        """
+        Detect the data type of a structured data sample.
+
+        Args:
+            sample: Data sample to analyze (string content)
+
+        Returns:
+            dict with detected_type, confidence, and optional metadata
+        """
+
+        input = {
+            "operation": "detect-type",
+            "sample": sample
+        }
+
+        response = self.request(
+            "service/structured-diag",
+            input
+        )
+
+        # Check for system-level error
+        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["detected-type"]
+
+    def generate_descriptor(self, sample, data_type, schema_name, options=None):
+        """
+        Generate a descriptor for structured data mapping to a specific schema.
+
+        Args:
+            sample: Data sample to analyze (string content)
+            data_type: Data type (csv, json, xml)
+            schema_name: Target schema name for descriptor generation
+            options: Optional parameters (e.g., delimiter for CSV)
+
+        Returns:
+            dict with descriptor and metadata
+        """
+
+        input = {
+            "operation": "generate-descriptor",
+            "sample": sample,
+            "type": data_type,
+            "schema-name": schema_name
+        }
+
+        if options:
+            input["options"] = options
+
+        response = self.request(
+            "service/structured-diag",
+            input
+        )
+
+        # Check for system-level error
+        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["descriptor"]
+
+    def diagnose_data(self, sample, schema_name=None, options=None):
+        """
+        Perform combined data diagnosis: detect type and generate descriptor.
+
+        Args:
+            sample: Data sample to analyze (string content)
+            schema_name: Optional target schema name for descriptor generation
+            options: Optional parameters (e.g., delimiter for CSV)
+
+        Returns:
+            dict with detected_type, confidence, descriptor, and metadata
+        """
+
+        input = {
+            "operation": "diagnose",
+            "sample": sample
+        }
+
+        if schema_name:
+            input["schema-name"] = schema_name
+
+        if options:
+            input["options"] = options
+
+        response = self.request(
+            "service/structured-diag",
+            input
+        )
+
+        # Check for system-level error
+        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 schema_selection(self, sample, options=None):
+        """
+        Select matching schemas for a data sample using prompt analysis.
+
+        Args:
+            sample: Data sample to analyze (string content)
+            options: Optional parameters
+
+        Returns:
+            dict with schema_matches array and metadata
+        """
+
+        input = {
+            "operation": "schema-selection",
+            "sample": sample
+        }
+
+        if options:
+            input["options"] = options
+
+        response = self.request(
+            "service/structured-diag",
+            input
+        )
+
+        # Check for system-level error
+        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["schema-matches"]
+

trustgraph_base-1.4.6/trustgraph/base_version.py

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

{trustgraph_base-1.4.4 → trustgraph_base-1.4.6}/trustgraph/messaging/__init__.py

@@ -24,6 +24,7 @@ from .translators.embeddings_query import (
 from .translators.objects_query import ObjectsQueryRequestTranslator, ObjectsQueryResponseTranslator
 from .translators.nlp_query import QuestionToStructuredQueryRequestTranslator, QuestionToStructuredQueryResponseTranslator
 from .translators.structured_query import StructuredQueryRequestTranslator, StructuredQueryResponseTranslator
+from .translators.diagnosis import StructuredDataDiagnosisRequestTranslator, StructuredDataDiagnosisResponseTranslator
 
 # Register all service translators
 TranslatorRegistry.register_service(
@@ -123,11 +124,17 @@ TranslatorRegistry.register_service(
 )
 
 TranslatorRegistry.register_service(
-    "structured-query", 
-    StructuredQueryRequestTranslator(), 
+    "structured-query",
+    StructuredQueryRequestTranslator(),
     StructuredQueryResponseTranslator()
 )
 
+TranslatorRegistry.register_service(
+    "structured-diag",
+    StructuredDataDiagnosisRequestTranslator(),
+    StructuredDataDiagnosisResponseTranslator()
+)
+
 # Register single-direction translators for document loading
 TranslatorRegistry.register_request("document", DocumentTranslator())
 TranslatorRegistry.register_request("text-document", TextDocumentTranslator())

{trustgraph_base-1.4.4 → trustgraph_base-1.4.6}/trustgraph/messaging/translators/__init__.py

@@ -18,3 +18,4 @@ from .embeddings_query import (
     GraphEmbeddingsRequestTranslator, GraphEmbeddingsResponseTranslator
 )
 from .objects_query import ObjectsQueryRequestTranslator, ObjectsQueryResponseTranslator
+from .diagnosis import StructuredDataDiagnosisRequestTranslator, StructuredDataDiagnosisResponseTranslator

trustgraph_base-1.4.6/trustgraph/messaging/translators/diagnosis.py

@@ -0,0 +1,67 @@
+from typing import Dict, Any, Tuple
+import json
+from ...schema import StructuredDataDiagnosisRequest, StructuredDataDiagnosisResponse
+from .base import MessageTranslator
+
+
+class StructuredDataDiagnosisRequestTranslator(MessageTranslator):
+    """Translator for StructuredDataDiagnosisRequest schema objects"""
+
+    def to_pulsar(self, data: Dict[str, Any]) -> StructuredDataDiagnosisRequest:
+        return StructuredDataDiagnosisRequest(
+            operation=data["operation"],
+            sample=data["sample"],
+            type=data.get("type", ""),
+            schema_name=data.get("schema-name", ""),
+            options=data.get("options", {})
+        )
+
+    def from_pulsar(self, obj: StructuredDataDiagnosisRequest) -> Dict[str, Any]:
+        result = {
+            "operation": obj.operation,
+            "sample": obj.sample,
+        }
+
+        # Add optional fields if they exist
+        if obj.type:
+            result["type"] = obj.type
+        if obj.schema_name:
+            result["schema-name"] = obj.schema_name
+        if obj.options:
+            result["options"] = obj.options
+
+        return result
+
+
+class StructuredDataDiagnosisResponseTranslator(MessageTranslator):
+    """Translator for StructuredDataDiagnosisResponse schema objects"""
+
+    def to_pulsar(self, data: Dict[str, Any]) -> StructuredDataDiagnosisResponse:
+        raise NotImplementedError("Response translation to Pulsar not typically needed")
+
+    def from_pulsar(self, obj: StructuredDataDiagnosisResponse) -> Dict[str, Any]:
+        result = {
+            "operation": obj.operation
+        }
+
+        # Add optional response fields if they exist
+        if obj.detected_type:
+            result["detected-type"] = obj.detected_type
+        if obj.confidence is not None:
+            result["confidence"] = obj.confidence
+        if obj.descriptor:
+            # Parse JSON-encoded descriptor
+            try:
+                result["descriptor"] = json.loads(obj.descriptor)
+            except (json.JSONDecodeError, TypeError):
+                result["descriptor"] = obj.descriptor
+        if obj.metadata:
+            result["metadata"] = obj.metadata
+        if obj.schema_matches is not None:
+            result["schema-matches"] = obj.schema_matches
+
+        return result
+
+    def from_response_with_completion(self, obj: StructuredDataDiagnosisResponse) -> Tuple[Dict[str, Any], bool]:
+        """Returns (response_dict, is_final)"""
+        return self.from_pulsar(obj), True

{trustgraph_base-1.4.4 → trustgraph_base-1.4.6}/trustgraph/schema/services/__init__.py

@@ -9,4 +9,5 @@ from .library import *
 from .lookup import *
 from .nlp_query import *
 from .structured_query import *
-from .objects_query import *
+from .objects_query import *
+from .diagnosis import *

trustgraph_base-1.4.6/trustgraph/schema/services/diagnosis.py

@@ -0,0 +1,33 @@
+from pulsar.schema import Record, String, Map, Double, Array
+from ..core.primitives import Error
+
+############################################################################
+
+# Structured data diagnosis services
+
+class StructuredDataDiagnosisRequest(Record):
+    operation = String()  # "detect-type", "generate-descriptor", "diagnose", or "schema-selection"
+    sample = String()     # Data sample to analyze (text content)
+    type = String()       # Data type (csv, json, xml) - optional, required for generate-descriptor
+    schema_name = String() # Target schema name for descriptor generation - optional
+
+    # JSON encoded options (e.g., delimiter for CSV)
+    options = Map(String())
+
+class StructuredDataDiagnosisResponse(Record):
+    error = Error()
+
+    operation = String()         # The operation that was performed
+    detected_type = String()     # Detected data type (for detect-type/diagnose) - optional
+    confidence = Double()        # Confidence score for type detection - optional
+
+    # JSON encoded descriptor (for generate-descriptor/diagnose) - optional
+    descriptor = String()
+
+    # JSON encoded additional metadata (e.g., field count, sample records)
+    metadata = Map(String())
+
+    # Array of matching schema IDs (for schema-selection operation) - optional
+    schema_matches = Array(String())
+
+############################################################################

{trustgraph_base-1.4.4 → trustgraph_base-1.4.6}/trustgraph_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 1.4.4
+Version: 1.4.6
 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-1.4.4 → trustgraph_base-1.4.6}/trustgraph_base.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ trustgraph/messaging/translators/__init__.py
 trustgraph/messaging/translators/agent.py
 trustgraph/messaging/translators/base.py
 trustgraph/messaging/translators/config.py
+trustgraph/messaging/translators/diagnosis.py
 trustgraph/messaging/translators/document_loading.py
 trustgraph/messaging/translators/embeddings.py
 trustgraph/messaging/translators/embeddings_query.py
@@ -109,6 +110,7 @@ trustgraph/schema/knowledge/structured.py
 trustgraph/schema/services/__init__.py
 trustgraph/schema/services/agent.py
 trustgraph/schema/services/config.py
+trustgraph/schema/services/diagnosis.py
 trustgraph/schema/services/flow.py
 trustgraph/schema/services/library.py
 trustgraph/schema/services/llm.py

trustgraph_base-1.4.4/trustgraph/base_version.py

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