schema-guard-core 0.1.0__tar.gz

schema_guard_core-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: schema-guard-core
+Version: 0.1.0
+Summary: Structured Output Validator & Schema Enforcer SDK
+Project-URL: Homepage, https://github.com/NayanSrivastav/schema-guard
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.25.0
+
+# SchemaGuard Python SDK
+
+The official Python client for SchemaGuard — a runtime validation, monitoring, and coercion engine for protecting your LLM pipelines from bad JSON schemas.
+
+## Installation
+
+```bash
+pip install schemaguard
+```
+
+## Quick Start (Offline Mode)
+
+If you don't want to run the core Golang server, use the `LocalValidator` to catch schema drifts natively with exactly mapped formatting constraints dynamically directly in your Python code environments.
+
+```python
+from schemaguard import LocalValidator
+
+schema = {
+    "type": "object",
+    "properties": { "id": {"type": "integer"} },
+    "required": ["id"]
+}
+
+validator = LocalValidator(schema)
+llm_response = '```json\n{"id": 123}\n```'
+
+is_valid, data, errors = validator.validate(llm_response)
+if is_valid:
+    print("Clean format!", data["id"])
+else:
+    print("Errors:", errors)
+```
+
+## Production Mode (API Client)
+
+In production, SchemaGuard manages schema distribution caching, active OpenTelemetry cost tracking, and circuit breakers directly locally or on your private clusters utilizing our blazingly fast Golang engine.
+
+```python
+from schemaguard import SchemaGuardClient
+
+client = SchemaGuardClient(api_key="sg_...", base_url="http://localhost:8080/v1")
+
+res = client.validate(schema_name="invoice_schema", version="latest", payload='{"total": "-10"}')
+if not res.get("status") == "PASS":
+    print(res["errors"]) # Maps dynamically cleanly for prompt re-injection strategies
+```
+
+## LangChain Integration
+
+Using our native parser natively integrates into LangChain's existing RetryingOutputParser bounds without needing human configurations.
+
+```python
+from schemaguard_parser import SchemaGuardOutputParser
+
+parser = SchemaGuardOutputParser(schema_dict=schema)
+prompt = PromptTemplate(
+    template="Extract invoice details.\n{format_instructions}\n{context}",
+    input_variables=["context"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+)
+
+chain = prompt | llm | parser
+
+# Automatically drops schema bounds into the prompt, extracts response payloads, validates constraints, and natively rejects outputs throwing `OutputParserException`.
+```

schema_guard_core-0.1.0/README.md

@@ -0,0 +1,65 @@
+# SchemaGuard Python SDK
+
+The official Python client for SchemaGuard — a runtime validation, monitoring, and coercion engine for protecting your LLM pipelines from bad JSON schemas.
+
+## Installation
+
+```bash
+pip install schemaguard
+```
+
+## Quick Start (Offline Mode)
+
+If you don't want to run the core Golang server, use the `LocalValidator` to catch schema drifts natively with exactly mapped formatting constraints dynamically directly in your Python code environments.
+
+```python
+from schemaguard import LocalValidator
+
+schema = {
+    "type": "object",
+    "properties": { "id": {"type": "integer"} },
+    "required": ["id"]
+}
+
+validator = LocalValidator(schema)
+llm_response = '```json\n{"id": 123}\n```'
+
+is_valid, data, errors = validator.validate(llm_response)
+if is_valid:
+    print("Clean format!", data["id"])
+else:
+    print("Errors:", errors)
+```
+
+## Production Mode (API Client)
+
+In production, SchemaGuard manages schema distribution caching, active OpenTelemetry cost tracking, and circuit breakers directly locally or on your private clusters utilizing our blazingly fast Golang engine.
+
+```python
+from schemaguard import SchemaGuardClient
+
+client = SchemaGuardClient(api_key="sg_...", base_url="http://localhost:8080/v1")
+
+res = client.validate(schema_name="invoice_schema", version="latest", payload='{"total": "-10"}')
+if not res.get("status") == "PASS":
+    print(res["errors"]) # Maps dynamically cleanly for prompt re-injection strategies
+```
+
+## LangChain Integration
+
+Using our native parser natively integrates into LangChain's existing RetryingOutputParser bounds without needing human configurations.
+
+```python
+from schemaguard_parser import SchemaGuardOutputParser
+
+parser = SchemaGuardOutputParser(schema_dict=schema)
+prompt = PromptTemplate(
+    template="Extract invoice details.\n{format_instructions}\n{context}",
+    input_variables=["context"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+)
+
+chain = prompt | llm | parser
+
+# Automatically drops schema bounds into the prompt, extracts response payloads, validates constraints, and natively rejects outputs throwing `OutputParserException`.
+```

schema_guard_core-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "schema-guard-core"
+version = "0.1.0"
+description = "Structured Output Validator & Schema Enforcer SDK"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "jsonschema>=4.0.0",
+    "pydantic>=2.0.0",
+    "requests>=2.25.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/NayanSrivastav/schema-guard"

schema_guard_core-0.1.0/schema_guard_core.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: schema-guard-core
+Version: 0.1.0
+Summary: Structured Output Validator & Schema Enforcer SDK
+Project-URL: Homepage, https://github.com/NayanSrivastav/schema-guard
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.25.0
+
+# SchemaGuard Python SDK
+
+The official Python client for SchemaGuard — a runtime validation, monitoring, and coercion engine for protecting your LLM pipelines from bad JSON schemas.
+
+## Installation
+
+```bash
+pip install schemaguard
+```
+
+## Quick Start (Offline Mode)
+
+If you don't want to run the core Golang server, use the `LocalValidator` to catch schema drifts natively with exactly mapped formatting constraints dynamically directly in your Python code environments.
+
+```python
+from schemaguard import LocalValidator
+
+schema = {
+    "type": "object",
+    "properties": { "id": {"type": "integer"} },
+    "required": ["id"]
+}
+
+validator = LocalValidator(schema)
+llm_response = '```json\n{"id": 123}\n```'
+
+is_valid, data, errors = validator.validate(llm_response)
+if is_valid:
+    print("Clean format!", data["id"])
+else:
+    print("Errors:", errors)
+```
+
+## Production Mode (API Client)
+
+In production, SchemaGuard manages schema distribution caching, active OpenTelemetry cost tracking, and circuit breakers directly locally or on your private clusters utilizing our blazingly fast Golang engine.
+
+```python
+from schemaguard import SchemaGuardClient
+
+client = SchemaGuardClient(api_key="sg_...", base_url="http://localhost:8080/v1")
+
+res = client.validate(schema_name="invoice_schema", version="latest", payload='{"total": "-10"}')
+if not res.get("status") == "PASS":
+    print(res["errors"]) # Maps dynamically cleanly for prompt re-injection strategies
+```
+
+## LangChain Integration
+
+Using our native parser natively integrates into LangChain's existing RetryingOutputParser bounds without needing human configurations.
+
+```python
+from schemaguard_parser import SchemaGuardOutputParser
+
+parser = SchemaGuardOutputParser(schema_dict=schema)
+prompt = PromptTemplate(
+    template="Extract invoice details.\n{format_instructions}\n{context}",
+    input_variables=["context"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+)
+
+chain = prompt | llm | parser
+
+# Automatically drops schema bounds into the prompt, extracts response payloads, validates constraints, and natively rejects outputs throwing `OutputParserException`.
+```

schema_guard_core-0.1.0/schema_guard_core.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+schema_guard_core.egg-info/PKG-INFO
+schema_guard_core.egg-info/SOURCES.txt
+schema_guard_core.egg-info/dependency_links.txt
+schema_guard_core.egg-info/requires.txt
+schema_guard_core.egg-info/top_level.txt
+schemaguard/__init__.py
+schemaguard/client.py
+schemaguard/local.py
+tests/test_local_validator_bdd.py

schema_guard_core-0.1.0/schema_guard_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

schema_guard_core-0.1.0/schema_guard_core.egg-info/requires.txt

@@ -0,0 +1,3 @@
+jsonschema>=4.0.0
+pydantic>=2.0.0
+requests>=2.25.0

schema_guard_core-0.1.0/schema_guard_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+schemaguard

schema_guard_core-0.1.0/schemaguard/__init__.py

@@ -0,0 +1,4 @@
+from .client import SchemaGuardClient
+from .local import LocalValidator
+
+__all__ = ["SchemaGuardClient", "LocalValidator"]

schema_guard_core-0.1.0/schemaguard/client.py

@@ -0,0 +1,24 @@
+import requests
+from typing import Dict, Any, Optional
+
+class SchemaGuardClient:
+    """
+    Remote client for delegating LLM response validation to the Golang core platform.
+    Designed to interact securely with the API engine metrics and circuit breaking layers.
+    """
+    def __init__(self, api_key: str, base_url: str = "http://localhost:8080/v1"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {self.api_key}"})
+
+    def validate(self, schema_name: str, payload: str, version: Optional[str] = "latest") -> Dict[str, Any]:
+        """
+        Submits unstructured LLM payload text entirely securely targeting the Schema registry constraints.
+        """
+        response = self.session.post(
+            f"{self.base_url}/validate",
+            json={"schema_name": schema_name, "version": version, "payload": payload}
+        )
+        response.raise_for_status()
+        return response.json()

schema_guard_core-0.1.0/schemaguard/local.py

@@ -0,0 +1,73 @@
+import json
+import jsonschema
+from typing import Dict, Any, Tuple
+
+class LocalValidator:
+    """
+    Offline local MVP capability to test strict syntax validations without launching 
+    the full Go binary. Useful for CI pipelines and quick testing natively via Python.
+    """
+    @staticmethod
+    def coerce_heuristics(val: Any) -> Any:
+        # Replicates Go's natively resilient coercion boundaries seamlessly 
+        if isinstance(val, str):
+            if val.isdigit():
+                return int(val)
+            try:
+                return float(val)
+            except ValueError:
+                pass
+            if val.lower() == "true":
+                return True
+            if val.lower() == "false":
+                return False
+            if (val.startswith('{') and val.endswith('}')) or (val.startswith('[') and val.endswith(']')):
+                try:
+                    parsed = json.loads(val)
+                    return LocalValidator.coerce_heuristics(parsed)
+                except Exception:
+                    pass
+            return val
+        elif isinstance(val, dict):
+            return {k: LocalValidator.coerce_heuristics(v) for k, v in val.items()}
+        elif isinstance(val, list):
+            return [LocalValidator.coerce_heuristics(v) for v in val]
+        return val
+    def __init__(self, schema: Dict[str, Any]):
+        self.schema = schema
+
+    def validate(self, payload: str) -> Tuple[bool, Any, list]:
+        """
+        Returns (is_valid, parsed_json_or_raw, [errors])
+        """
+        raw = payload
+        
+        # 1. Attempt to extract organic JSON block hidden within conversational markdown 
+        if "```json" in payload:
+            try:
+                raw = payload.split("```json")[1].split("```")[0].strip()
+            except IndexError:
+                pass
+        elif "```" in payload:
+            try:
+                raw = payload.split("```")[1].split("```")[0].strip()
+            except IndexError:
+                pass
+
+        # 2. Syntax Check
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as e:
+            return False, raw, [f"Invalid JSON Format (Root Engine): {str(e)}"]
+
+        # 3. Automatic Resilient Coercion matching Backend logic mapping
+        data = self.coerce_heuristics(data)
+
+        # 3. Ruleset Validation
+        try:
+            jsonschema.validate(instance=data, schema=self.schema)
+            return True, data, []
+        except jsonschema.exceptions.ValidationError as e:
+            # Map precise path bounds (e.g. metadata.views object failed type constraints)
+            path = ".".join([str(p) for p in e.path]) if e.path else "root"
+            return False, data, [f"Field '{path}': {e.message}"]

schema_guard_core-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

schema_guard_core-0.1.0/tests/test_local_validator_bdd.py

@@ -0,0 +1,64 @@
+import pytest
+from schemaguard.local import LocalValidator
+
+class TestSchemaGuardLocalValidation_BDD:
+    """Feature: Offline Schema Verification & Markdown Extraction via Python SDK natively"""
+
+    def setup_method(self):
+        # GIVEN: The developer initializes a heavily strict schema offline cache natively seamlessly
+        self.schema = {
+            "type": "object",
+            "properties": {
+                "age": {"type": "integer"}
+            },
+            "required": ["age"]
+        }
+        self.validator = LocalValidator(self.schema)
+
+    # -------------------------------------------------------------------------
+    # Scenario 1: Validating a perfectly structured JSON payload securely
+    # -------------------------------------------------------------------------
+    def test_scenario_validating_perfect_json_payload(self):
+        # GIVEN an incoming AI request containing correct JSON mapping bindings internally
+        valid_llm_response = '{"age": 25}'
+
+        # WHEN the Python SDK parses the generated response locally isolating constraints accurately
+        is_valid, data, errors = self.validator.validate(valid_llm_response)
+
+        # THEN the system should trigger a PASS cleanly and extract the integer functionally
+        assert is_valid is True, "Expected valid execution natively mapped truthfully"
+        assert data["age"] == 25
+        assert len(errors) == 0
+
+    # -------------------------------------------------------------------------
+    # Scenario 2: Fixing a hallucinated LLM markdown response natively
+    # -------------------------------------------------------------------------
+    def test_scenario_fixing_hallucinated_markdown(self):
+        # GIVEN a conversational payload containing messy markdown and implicitly wrong type formatting heavily natively
+        hallucinated_response = "Here is the extracted information requested:\n```json\n{\"age\": \"25\"}\n```\nLet me know if you need anything else!"
+
+        # WHEN the Python SDK dynamically truncates the markdown formatting attempting fallback logic internally
+        is_valid, data, errors = self.validator.validate(hallucinated_response)
+
+        # THEN it translates the parsed string `"25"` natively into the rigid integer `25` exactly bypassing LLM limits safely
+        assert is_valid is True, f"Expected Coerced String mapping natively internally structurally. Errors: {errors}"
+        assert data["age"] == 25, "Expected AST translation mapping the string inherently cleanly!"
+        assert len(errors) == 0
+
+    # -------------------------------------------------------------------------
+    # Scenario 3: Rejecting an absolutely broken payload logically dynamically
+    # -------------------------------------------------------------------------
+    def test_scenario_rejecting_missing_parameters(self):
+        # GIVEN an LLM output completely hallucinating past the critically required 'age' variable logically
+        broken_response = '{"name": "Enterprise Engineer"}'
+
+        # WHEN the internal Local SDK strict evaluation runs directly targeting formatting structurally
+        is_valid, data, errors = self.validator.validate(broken_response)
+
+        # THEN the engine traps a FAIL securely catching the exact AST path failure seamlessly mapping back error arrays logically
+        assert is_valid is False
+        assert len(errors) > 0
+        
+        # Verify that the missing 'age' property was correctly flagged inherently 
+        error_message_contains_age = any("age" in err for err in errors)
+        assert error_message_contains_age is True, "Expected specific error message dictating 'age' explicitly!"