trustgraph-base 1.4.5__tar.gz → 1.4.7__tar.gz

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/PKG-INFO

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

@@ -8,6 +8,7 @@ from . library import Library
 from . flow import Flow
 from . config import Config
 from . knowledge import Knowledge
+from . collection import Collection
 from . exceptions import *
 from . types import *
 
@@ -68,3 +69,6 @@ class Api:
 
     def library(self):
         return Library(self)
+
+    def collection(self):
+        return Collection(self)

trustgraph_base-1.4.7/trustgraph/api/collection.py

@@ -0,0 +1,90 @@
+import datetime
+import logging
+
+from . types import CollectionMetadata
+from . exceptions import *
+
+logger = logging.getLogger(__name__)
+
+class Collection:
+
+    def __init__(self, api):
+        self.api = api
+
+    def request(self, request):
+        return self.api.request(f"collection-management", request)
+
+    def list_collections(self, user, tag_filter=None):
+
+        input = {
+            "operation": "list-collections",
+            "user": user,
+        }
+
+        if tag_filter:
+            input["tag_filter"] = tag_filter
+
+        object = self.request(input)
+
+        try:
+            return [
+                CollectionMetadata(
+                    user = v["user"],
+                    collection = v["collection"],
+                    name = v["name"],
+                    description = v["description"],
+                    tags = v["tags"],
+                    created_at = v["created_at"],
+                    updated_at = v["updated_at"]
+                )
+                for v in object["collections"]
+            ]
+        except Exception as e:
+            logger.error("Failed to parse collection list response", exc_info=True)
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def update_collection(self, user, collection, name=None, description=None, tags=None):
+
+        input = {
+            "operation": "update-collection",
+            "user": user,
+            "collection": collection,
+        }
+
+        if name is not None:
+            input["name"] = name
+        if description is not None:
+            input["description"] = description
+        if tags is not None:
+            input["tags"] = tags
+
+        object = self.request(input)
+
+        try:
+            if "collections" in object and object["collections"]:
+                v = object["collections"][0]
+                return CollectionMetadata(
+                    user = v["user"],
+                    collection = v["collection"],
+                    name = v["name"],
+                    description = v["description"],
+                    tags = v["tags"],
+                    created_at = v["created_at"],
+                    updated_at = v["updated_at"]
+                )
+            return None
+        except Exception as e:
+            logger.error("Failed to parse collection update response", exc_info=True)
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def delete_collection(self, user, collection):
+
+        input = {
+            "operation": "delete-collection",
+            "user": user,
+            "collection": collection,
+        }
+
+        object = self.request(input)
+
+        return {}

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/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.5 → trustgraph_base-1.4.7}/trustgraph/api/types.py

@@ -41,3 +41,13 @@ class ProcessingMetadata:
     user : str
     collection : str
     tags : List[str]
+
+@dataclasses.dataclass
+class CollectionMetadata:
+    user : str
+    collection : str
+    name : str
+    description : str
+    tags : List[str]
+    created_at : str
+    updated_at : str

trustgraph_base-1.4.7/trustgraph/base_version.py

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

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/trustgraph/messaging/__init__.py

@@ -25,6 +25,7 @@ from .translators.objects_query import ObjectsQueryRequestTranslator, ObjectsQue
 from .translators.nlp_query import QuestionToStructuredQueryRequestTranslator, QuestionToStructuredQueryResponseTranslator
 from .translators.structured_query import StructuredQueryRequestTranslator, StructuredQueryResponseTranslator
 from .translators.diagnosis import StructuredDataDiagnosisRequestTranslator, StructuredDataDiagnosisResponseTranslator
+from .translators.collection import CollectionManagementRequestTranslator, CollectionManagementResponseTranslator
 
 # Register all service translators
 TranslatorRegistry.register_service(
@@ -135,6 +136,12 @@ TranslatorRegistry.register_service(
     StructuredDataDiagnosisResponseTranslator()
 )
 
+TranslatorRegistry.register_service(
+    "collection-management",
+    CollectionManagementRequestTranslator(),
+    CollectionManagementResponseTranslator()
+)
+
 # Register single-direction translators for document loading
 TranslatorRegistry.register_request("document", DocumentTranslator())
 TranslatorRegistry.register_request("text-document", TextDocumentTranslator())

trustgraph_base-1.4.7/trustgraph/messaging/translators/collection.py

@@ -0,0 +1,112 @@
+from typing import Dict, Any, List
+from ...schema import CollectionManagementRequest, CollectionManagementResponse, CollectionMetadata, Error
+from .base import MessageTranslator
+
+
+class CollectionManagementRequestTranslator(MessageTranslator):
+    """Translator for CollectionManagementRequest schema objects"""
+
+    def to_pulsar(self, data: Dict[str, Any]) -> CollectionManagementRequest:
+        return CollectionManagementRequest(
+            operation=data.get("operation", ""),
+            user=data.get("user", ""),
+            collection=data.get("collection", ""),
+            timestamp=data.get("timestamp", ""),
+            name=data.get("name", ""),
+            description=data.get("description", ""),
+            tags=data.get("tags", []),
+            created_at=data.get("created_at", ""),
+            updated_at=data.get("updated_at", ""),
+            tag_filter=data.get("tag_filter", []),
+            limit=data.get("limit", 50)
+        )
+
+    def from_pulsar(self, obj: CollectionManagementRequest) -> Dict[str, Any]:
+        result = {}
+
+        if obj.operation:
+            result["operation"] = obj.operation
+        if obj.user:
+            result["user"] = obj.user
+        if obj.collection:
+            result["collection"] = obj.collection
+        if obj.timestamp:
+            result["timestamp"] = obj.timestamp
+        if obj.name:
+            result["name"] = obj.name
+        if obj.description:
+            result["description"] = obj.description
+        if obj.tags:
+            result["tags"] = list(obj.tags)
+        if obj.created_at:
+            result["created_at"] = obj.created_at
+        if obj.updated_at:
+            result["updated_at"] = obj.updated_at
+        if obj.tag_filter:
+            result["tag_filter"] = list(obj.tag_filter)
+        if obj.limit:
+            result["limit"] = obj.limit
+
+        return result
+
+
+class CollectionManagementResponseTranslator(MessageTranslator):
+    """Translator for CollectionManagementResponse schema objects"""
+
+    def to_pulsar(self, data: Dict[str, Any]) -> CollectionManagementResponse:
+        # Handle error
+        error = None
+        if "error" in data and data["error"]:
+            error_data = data["error"]
+            error = Error(
+                type=error_data.get("type", ""),
+                message=error_data.get("message", "")
+            )
+
+        # Handle collections array
+        collections = []
+        if "collections" in data:
+            for coll_data in data["collections"]:
+                collections.append(CollectionMetadata(
+                    user=coll_data.get("user", ""),
+                    collection=coll_data.get("collection", ""),
+                    name=coll_data.get("name", ""),
+                    description=coll_data.get("description", ""),
+                    tags=coll_data.get("tags", []),
+                    created_at=coll_data.get("created_at", ""),
+                    updated_at=coll_data.get("updated_at", "")
+                ))
+
+        return CollectionManagementResponse(
+            success=data.get("success", ""),
+            error=error,
+            timestamp=data.get("timestamp", ""),
+            collections=collections
+        )
+
+    def from_pulsar(self, obj: CollectionManagementResponse) -> Dict[str, Any]:
+        result = {}
+
+        if obj.success:
+            result["success"] = obj.success
+        if obj.error:
+            result["error"] = {
+                "type": obj.error.type,
+                "message": obj.error.message
+            }
+        if obj.timestamp:
+            result["timestamp"] = obj.timestamp
+        if obj.collections:
+            result["collections"] = []
+            for coll in obj.collections:
+                result["collections"].append({
+                    "user": coll.user,
+                    "collection": coll.collection,
+                    "name": coll.name,
+                    "description": coll.description,
+                    "tags": list(coll.tags) if coll.tags else [],
+                    "created_at": coll.created_at,
+                    "updated_at": coll.updated_at
+                })
+
+        return result

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/trustgraph/messaging/translators/diagnosis.py

@@ -57,6 +57,8 @@ class StructuredDataDiagnosisResponseTranslator(MessageTranslator):
                 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
 

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/trustgraph/schema/services/__init__.py

@@ -10,4 +10,6 @@ from .lookup import *
 from .nlp_query import *
 from .structured_query import *
 from .objects_query import *
-from .diagnosis import *
+from .diagnosis import *
+from .collection import *
+from .storage import *

trustgraph_base-1.4.7/trustgraph/schema/services/collection.py

@@ -0,0 +1,60 @@
+from pulsar.schema import Record, String, Integer, Array
+from datetime import datetime
+
+from ..core.primitives import Error
+from ..core.topic import topic
+
+############################################################################
+
+# Collection management operations
+
+# Collection metadata operations (for librarian service)
+
+class CollectionMetadata(Record):
+    """Collection metadata record"""
+    user = String()
+    collection = String()
+    name = String()
+    description = String()
+    tags = Array(String())
+    created_at = String()  # ISO timestamp
+    updated_at = String()  # ISO timestamp
+
+############################################################################
+
+class CollectionManagementRequest(Record):
+    """Request for collection management operations"""
+    operation = String()  # e.g., "delete-collection"
+
+    # For 'list-collections'
+    user = String()
+    collection = String()
+    timestamp = String()  # ISO timestamp
+    name = String()
+    description = String()
+    tags = Array(String())
+    created_at = String()  # ISO timestamp
+    updated_at = String()  # ISO timestamp
+
+    # For list
+    tag_filter = Array(String())  # Optional filter by tags
+    limit = Integer()
+
+class CollectionManagementResponse(Record):
+    """Response for collection management operations"""
+    success = String()  # "true" or "false"
+    error = Error()  # Only populated if success is "false"
+    timestamp = String()  # ISO timestamp
+    collections = Array(CollectionMetadata())
+
+
+############################################################################
+
+# Topics
+
+collection_request_queue = topic(
+    'collection', kind='non-persistent', namespace='request'
+)
+collection_response_queue = topic(
+    'collection', kind='non-persistent', namespace='response'
+)

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/trustgraph/schema/services/diagnosis.py

@@ -1,4 +1,4 @@
-from pulsar.schema import Record, String, Map, Double
+from pulsar.schema import Record, String, Map, Double, Array
 from ..core.primitives import Error
 
 ############################################################################
@@ -6,7 +6,7 @@ from ..core.primitives import Error
 # Structured data diagnosis services
 
 class StructuredDataDiagnosisRequest(Record):
-    operation = String()  # "detect-type", "generate-descriptor", or "diagnose"
+    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
@@ -27,4 +27,7 @@ class StructuredDataDiagnosisResponse(Record):
     # 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.7/trustgraph/schema/services/storage.py

@@ -0,0 +1,42 @@
+from pulsar.schema import Record, String
+
+from ..core.primitives import Error
+from ..core.topic import topic
+
+############################################################################
+
+# Storage management operations
+
+class StorageManagementRequest(Record):
+    """Request for storage management operations sent to store processors"""
+    operation = String()  # e.g., "delete-collection"
+    user = String()
+    collection = String()
+
+class StorageManagementResponse(Record):
+    """Response from storage processors for management operations"""
+    error = Error()  # Only populated if there's an error, if null success
+
+############################################################################
+
+# Storage management topics
+
+# Topics for sending collection management requests to different storage types
+vector_storage_management_topic = topic(
+    'vector-storage-management', kind='non-persistent', namespace='request'
+)
+
+object_storage_management_topic = topic(
+    'object-storage-management', kind='non-persistent', namespace='request'
+)
+
+triples_storage_management_topic = topic(
+    'triples-storage-management', kind='non-persistent', namespace='request'
+)
+
+# Topic for receiving responses from storage processors
+storage_management_response_topic = topic(
+    'storage-management', kind='non-persistent', namespace='response'
+)
+
+############################################################################

{trustgraph_base-1.4.5 → trustgraph_base-1.4.7}/trustgraph_base.egg-info/PKG-INFO

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

@@ -6,6 +6,7 @@ trustgraph/log_level.py
 trustgraph/rdf.py
 trustgraph/api/__init__.py
 trustgraph/api/api.py
+trustgraph/api/collection.py
 trustgraph/api/config.py
 trustgraph/api/exceptions.py
 trustgraph/api/flow.py
@@ -72,6 +73,7 @@ trustgraph/messaging/registry.py
 trustgraph/messaging/translators/__init__.py
 trustgraph/messaging/translators/agent.py
 trustgraph/messaging/translators/base.py
+trustgraph/messaging/translators/collection.py
 trustgraph/messaging/translators/config.py
 trustgraph/messaging/translators/diagnosis.py
 trustgraph/messaging/translators/document_loading.py
@@ -109,6 +111,7 @@ trustgraph/schema/knowledge/rows.py
 trustgraph/schema/knowledge/structured.py
 trustgraph/schema/services/__init__.py
 trustgraph/schema/services/agent.py
+trustgraph/schema/services/collection.py
 trustgraph/schema/services/config.py
 trustgraph/schema/services/diagnosis.py
 trustgraph/schema/services/flow.py
@@ -120,6 +123,7 @@ trustgraph/schema/services/objects_query.py
 trustgraph/schema/services/prompt.py
 trustgraph/schema/services/query.py
 trustgraph/schema/services/retrieval.py
+trustgraph/schema/services/storage.py
 trustgraph/schema/services/structured_query.py
 trustgraph_base.egg-info/PKG-INFO
 trustgraph_base.egg-info/SOURCES.txt

trustgraph_base-1.4.5/trustgraph/base_version.py

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