guardianhub 0.1.44__tar.gz

guardianhub-0.1.44/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rashmi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

guardianhub-0.1.44/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: guardianhub
+Version: 0.1.44
+Summary: Unified SDK for Local AI Guardian
+License: MIT
+License-File: LICENSE
+Author: Jayant
+Author-email: jayant@yantramops.com
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: dev
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: fastapi (>=0.123.0)
+Requires-Dist: httpcore (>=0.17.0)
+Requires-Dist: httpx (>=0.24.0)
+Requires-Dist: opentelemetry-api (>=1.38.0)
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.38.0)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.59b0)
+Requires-Dist: opentelemetry-instrumentation-httpx (>=0.59b0)
+Requires-Dist: opentelemetry-sdk (>=1.38.0)
+Requires-Dist: prometheus-client (>=0.23.1)
+Requires-Dist: pycryptodome (>=3.18.0)
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: pydantic-settings (>=2.0.0)
+Requires-Dist: pytest (>=7.0.0) ; extra == "dev"
+Requires-Dist: pytest-asyncio (>=0.20.0) ; extra == "dev"
+Project-URL: Homepage, https://github.com/yantramai/guardianhub-sdk
+Project-URL: Source, https://github.com/yantramai/guardianhub-sdk
+Description-Content-Type: text/markdown
+
+# GuardianHub SDK
+
+A Python SDK for interacting with GuardianHub services, featuring a model registry and LLM client.
+
+## Features
+
+- Model registry with versioning
+- Async HTTP client for API interactions
+- Pydantic model support
+- Local development and testing tools
+
+## Installation
+
+```bash
+# Install from PyPI (when published)
+ssh-keygen -t ed25519 -C "rashmi@yantramops.com"
+pip install guardianhub-sdk
+
+# Or install in development mode
+pip install -e .[test]
+
+# 1. Remove the specified directory and its contents from the Git index.
+#    The --cached flag ensures the files are NOT deleted from your local disk.
+git rm -r --cached .github
+
+# 2. Add the .gitignore file (which now contains the new rules)
+git add .gitignore
+
+# 3. Commit the changes
+git commit -m "Cleanup: Remove .github directory from tracking and update .gitignore"
+
+git checkout -b dev
+git push -u origin dev
+
+
+git checkout dev
+git pull origin dev   # Ensure you have the latest code
+git checkout -b feature/model-registry # Name your branch descriptively
+git push -u origin feature/model-registry
+
+```
+
+## Usage
+
+```python
+from guardianhub_sdk.models.registry.loader import RegistryLoader
+
+# Initialize the loader
+loader = RegistryLoader()
+
+# Load a model
+model = await loader.load_model("UserModel", version="v1")
+```
+
+## Development
+
+### Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/your-username/guardianhub-sdk.git
+   cd guardianhub-sdk
+   ```
+
+2. Create a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. Install dependencies:
+   ```bash
+   pip install -e .[test]
+   ```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

guardianhub-0.1.44/README.md

@@ -0,0 +1,84 @@
+# GuardianHub SDK
+
+A Python SDK for interacting with GuardianHub services, featuring a model registry and LLM client.
+
+## Features
+
+- Model registry with versioning
+- Async HTTP client for API interactions
+- Pydantic model support
+- Local development and testing tools
+
+## Installation
+
+```bash
+# Install from PyPI (when published)
+ssh-keygen -t ed25519 -C "rashmi@yantramops.com"
+pip install guardianhub-sdk
+
+# Or install in development mode
+pip install -e .[test]
+
+# 1. Remove the specified directory and its contents from the Git index.
+#    The --cached flag ensures the files are NOT deleted from your local disk.
+git rm -r --cached .github
+
+# 2. Add the .gitignore file (which now contains the new rules)
+git add .gitignore
+
+# 3. Commit the changes
+git commit -m "Cleanup: Remove .github directory from tracking and update .gitignore"
+
+git checkout -b dev
+git push -u origin dev
+
+
+git checkout dev
+git pull origin dev   # Ensure you have the latest code
+git checkout -b feature/model-registry # Name your branch descriptively
+git push -u origin feature/model-registry
+
+```
+
+## Usage
+
+```python
+from guardianhub_sdk.models.registry.loader import RegistryLoader
+
+# Initialize the loader
+loader = RegistryLoader()
+
+# Load a model
+model = await loader.load_model("UserModel", version="v1")
+```
+
+## Development
+
+### Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/your-username/guardianhub-sdk.git
+   cd guardianhub-sdk
+   ```
+
+2. Create a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. Install dependencies:
+   ```bash
+   pip install -e .[test]
+   ```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT

guardianhub-0.1.44/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "guardianhub"
+version = "0.1.44"  # This will be overridden by Hatch's dynamic version
+# Note: Keep _version.py as the source of truth for version
+description = "Unified SDK for Local AI Guardian"
+authors = [
+    {name = "Jayant", email = "jayant@yantramops.com"}
+]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.24.0",
+    "pydantic>=2.0.0",
+    "pydantic-settings>=2.0.0",
+    "pycryptodome>=3.18.0",
+    "click>=8.0.0",
+    "httpcore>=0.17.0",
+    "prometheus-client>=0.23.1",
+    "fastapi>=0.123.0",
+    "opentelemetry-api>=1.38.0",
+    "opentelemetry-sdk>=1.38.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.38.0",
+    "opentelemetry-instrumentation-fastapi>=0.59b0",
+    "opentelemetry-instrumentation-httpx>=0.59b0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.20.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/yantramai/guardianhub-sdk"
+Source = "https://github.com/yantramai/guardianhub-sdk"
+
+[tool.hatch.version]
+path = "src/guardianhub/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/guardianhub"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/guardianhub"]

guardianhub-0.1.44/src/guardianhub/__init__.py

@@ -0,0 +1,17 @@
+# src/guardianhub/__init__.py
+from ._version import __version__  # version exported for users
+
+from .logging import get_logger,setup_logging
+from .utils.app_state import AppState
+from .utils.metrics import setup_metrics, get_metrics_registry
+from .utils.fastapi_utils import setup_middleware, setup_health_endpoint, setup_metrics_endpoint
+from .observability.instrumentation import configure_instrumentation
+
+# Expose public modules (minimal)
+__all__ = ["__version__",
+           "get_logger","setup_logging",
+           "AppState",
+           "setup_metrics","get_metrics_registry",
+           "setup_middleware","setup_health_endpoint","setup_metrics_endpoint",
+           "configure_instrumentation",
+           ]

guardianhub-0.1.44/src/guardianhub/_version.py

@@ -0,0 +1,3 @@
+# src/guardianhub/_version.py
+# single-source of truth for hatch version plugin
+__version__ = "0.1.44"

guardianhub-0.1.44/src/guardianhub/agents/runtime.py

@@ -0,0 +1,12 @@
+# guardianhub_sdk/agents/runtime.py
+from typing import Any, Dict
+
+
+class AgentRuntime:
+    def __init__(self, clients: Dict[str, Any]):
+        self.clients = clients
+
+
+    async def run(self, spec: Dict[str, Any]):
+        # stub: execute agent spec using clients
+        return {"status": "ok", "spec": spec}

guardianhub-0.1.44/src/guardianhub/auth/token_provider.py

@@ -0,0 +1,22 @@
+# guardianhub_sdk/auth/token_provider.py
+from typing import Optional
+
+
+class TokenProvider:
+
+
+    """Simple token provider stub. Replace with your vault/service account integration."""
+
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+        self._cached_token = api_key
+        self._expires_at = None
+
+
+    async def get_token(self) -> str:
+    # For server-to-server use, you may want to implement JWT/service-account exchange
+        if self._cached_token:
+            return self._cached_token
+        # fallback placeholder
+        return "placeholder"

guardianhub-0.1.44/src/guardianhub/clients/__init__.py

@@ -0,0 +1,2 @@
+from .vector_client import VectorClient
+from .llm_client import LLMClient

guardianhub-0.1.44/src/guardianhub/clients/classification_client.py

@@ -0,0 +1,52 @@
+"""Minio client with graceful error handling and connection management."""
+import logging
+from datetime import timedelta
+from typing import Optional, Union, Dict, Any
+
+import httpx
+
+from config import settings
+logger = logging.getLogger(__name__)
+
+class ClassificationClient:
+    """Minio client wrapper with graceful error handling."""
+
+    def __init__(self, base_url:str, poll_interval: int = 5, poll_timeout: int = 300):
+        self.initialized = False
+        self.client = None
+
+        try:
+            self.api_url = base_url.rstrip('/')
+            self.headers = {
+                "Accept": "application/json",
+            }
+            self.poll_interval = poll_interval
+            self.poll_timeout = poll_timeout
+
+            # Initialize the persistent httpx client here.
+            # DO NOT use it in an 'async with' block in methods, or it will be closed.
+            self.client = httpx.AsyncClient(headers=self.headers, base_url=self.api_url,
+                                            timeout=self.poll_timeout + 60)
+            self.initialized = True
+            logger.info(f"✅ Classification client connected to {settings.endpoints.CLASSIFICATION_ENDPOINT}")
+
+        except Exception as e:
+            logger.warning(
+                f"⚠️ Failed to initialize Classification client: {str(e)}. "
+                "Classification operations will be disabled."
+            )
+            self.initialized = False
+
+    async def classify(self, text: str,metadata:Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a presigned URL for uploading an object."""
+        if not self.initialized:
+            logger.warning("Classification client not initialized, cannot generate presigned URL")
+            return {}
+
+        try:
+            response = await self.client.post("/v1/document/classify", json={"text": text, "metadata":metadata})
+            return response.json()
+
+        except Exception as e:
+            logger.error(f"Failed to classify document: {str(e)}")
+            return {}

guardianhub-0.1.44/src/guardianhub/clients/graph_db_client.py

@@ -0,0 +1,161 @@
+# services/clients/neo4j_client.py (New File/Class)
+import datetime
+import json
+from typing import Dict, Any, Optional
+
+import httpx
+import yaml  # Must be imported for YAML output
+# Import all model classes to make them available at the package level
+from guardianhub.models.template.suggestion import TemplateSchemaSuggestion
+
+from config import settings
+from guardianhub_core import get_logger
+logger = get_logger(__name__)
+
+# NOTE: The actual driver must be injected/managed by the calling service (doc-template service)
+class GraphDBClient:
+    def __init__(self, base_url: str, poll_interval: int = 5, poll_timeout: int = 300):
+        """
+        Initializes the Paperless client.
+        """
+        self.api_url = base_url.rstrip('/')
+        self.api_token = settings.endpoints.GRAPH_DB_URL
+        self.headers = {
+            "Accept": "application/json",
+        }
+        self.poll_interval = poll_interval
+        self.poll_timeout = poll_timeout
+
+        # Initialize the persistent httpx client here.
+        # DO NOT use it in an 'async with' block in methods, or it will be closed.
+        self.client = httpx.AsyncClient(headers=self.headers, base_url=self.api_url, timeout=self.poll_timeout + 60)
+        logger.info("PaperlessClient initialized for URL: %s", self.api_url)
+
+    async def save_document_template(self, template: TemplateSchemaSuggestion) -> bool:
+        """
+        Creates a new DocumentTemplate node and links it to the Doc-Template Service
+        node by submitting a YAML payload to the ingestion endpoint.
+        """
+
+        # 1. Prepare Node Properties
+        template_properties = {
+            "template_id": template.template_id,
+            "document_type": template.document_type,
+            "template_name": template.template_name,
+            "required_keywords": template.required_keywords,
+            # The ingestion endpoint requires the schema to be stored as a property value.
+            # We must serialize the JSON schema dictionary to a string/YAML-safe string.
+            "json_schema_str": json.dumps(template.json_schema)
+        }
+
+        # 2. Construct the Graph Ingestion Dictionary (The YAML Payload Structure)
+        ingestion_payload = {
+            "nodes": [
+                {
+                    "type": "DocumentTemplate",
+                    "properties": template_properties
+                }
+            ],
+            "relationships": [
+                {
+                    "from": {
+                        "type": "PlatformService",
+                        "property": "name",
+                        "value": "doc-template-service"  # Matching the service node created at startup
+                    },
+                    "to": {
+                        "type": "DocumentTemplate",
+                        "property": "template_id",
+                        "value": template.template_id
+                    },
+                    "type": "MANAGES_TEMPLATE",
+                    "properties": {
+                        "link_date": datetime.datetime.now()
+                    }
+                }
+            ]
+        }
+
+        # 3. Convert to YAML
+        yaml_payload = yaml.dump(ingestion_payload, sort_keys=False)
+
+        # 4. POST to the ingestion endpoint
+        try:
+            response = await self.client.post(
+                "/ingest-yaml-schema",
+                content=yaml_payload,
+                headers={'Content-Type': 'application/x-yaml'},
+                timeout=30.0
+            )
+            response.raise_for_status()
+
+            response_json = response.json()
+            if response_json.get("status") == "success":
+                logger.info(f"✅ Template {template.template_id} successfully persisted via YAML ingestion.")
+                return True
+            else:
+                logger.error(
+                    f"Graph DB Service returned non-success status for template {template.template_id}: {response_json.get('message')}")
+                return False
+
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                f"HTTP error during YAML ingestion (Template {template.template_id}). Status: {e.response.status_code}. Detail: {e.response.text}",
+                exc_info=True
+            )
+            return False
+        except Exception as e:
+            logger.error(f"Failed to ingest template YAML for {template.template_id}: {e}", exc_info=True)
+            return False
+
+        # services/clients/neo4j_client.py (Corrected get_template_by_id)
+
+    async def get_template_by_id(self, template_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieves the properties of a DocumentTemplate node by its ID via the
+        /query-cypher endpoint.
+        """
+
+        # 1. Define the Cypher query
+        cypher_query = """
+        MATCH (t:DocumentTemplate {template_id: $template_id})
+        RETURN properties(t) as template
+        """
+
+        # 2. Prepare the JSON payload for the read endpoint
+        payload = {
+            "query": cypher_query,
+            "parameters": {"template_id": template_id}
+        }
+
+        try:
+            # 🛠️ FIX: Target the correct read endpoint and send JSON payload
+            response = await self.client.post(
+                "/query-cypher", # The correct read endpoint
+                json=payload,    # Send as JSON
+                timeout=30.0
+            )
+            response.raise_for_status()
+
+            response_json = response.json()
+
+            if response_json.get("status") == "success" and response_json.get("results"):
+                # The result is typically a list of dicts from Cypher execution
+                record = response_json["results"][0]
+                template_data = record["template"]
+
+                # Convert the stored JSON Schema string back to a dictionary
+                template_data['json_schema'] = json.loads(template_data.pop('json_schema_str'))
+
+                logger.info(f"✅ Template {template_id} successfully retrieved from GraphDB.")
+                return template_data
+            else:
+                logger.info(f"Template {template_id} not found or query failed: {response_json.get('message')}")
+                return None
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error retrieving template {template_id}. Status: {e.response.status_code}")
+            return None
+        except Exception as e:
+            logger.error(f"Failed to retrieve template {template_id} from Neo4j: {e}", exc_info=True)
+            return None

guardianhub-0.1.44/src/guardianhub/clients/llm.py

@@ -0,0 +1,2 @@
+class LLMClient:
+    pass