omnesight 1.1.0__py3-none-any.whl

omnesight/__init__.py

@@ -0,0 +1,40 @@
+"""
+Omnesight Python SDK
+Sovereign Operational Intelligence & Autonomous Execution Infrastructure
+"""
+
+from .client import AsyncOmnesight, Omnesight
+from .exceptions import (
+    AuthenticationError,
+    InternalServerError,
+    NotFoundError,
+    OmnesightError,
+    PolicyViolationError,
+    RateLimitError,
+)
+from .models import (
+    HackmalimInferRequest,
+    HackmalimInferResponse,
+    SandalfonChatRequest,
+    SandalfonChatResponse,
+    SandalfonDiscoverRequest,
+    SandalfonDiscoverResponse,
+)
+
+__version__ = "1.1.0"
+__all__ = [
+    "AsyncOmnesight",
+    "AuthenticationError",
+    "HackmalimInferRequest",
+    "HackmalimInferResponse",
+    "InternalServerError",
+    "NotFoundError",
+    "Omnesight",
+    "OmnesightError",
+    "PolicyViolationError",
+    "RateLimitError",
+    "SandalfonChatRequest",
+    "SandalfonChatResponse",
+    "SandalfonDiscoverRequest",
+    "SandalfonDiscoverResponse",
+]

omnesight/client.py

@@ -0,0 +1,181 @@
+"""
+Omnesight Client Implementation
+Supports synchronous and asynchronous execution, sovereign MLOps gateways,
+custom VPC endpoints, and automatic transport retries.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from .exceptions import (
+    AuthenticationError,
+    InternalServerError,
+    NotFoundError,
+    OmnesightError,
+    PolicyViolationError,
+    RateLimitError,
+)
+from .resources.actions import ActionsResource, AsyncActionsResource
+from .resources.hackmalim import AsyncHackmalimResource, HackmalimResource
+from .resources.reconciliation import (
+    AsyncReconciliationResource,
+    ReconciliationResource,
+)
+from .resources.sandalfon import AsyncSandalfonResource, SandalfonResource
+from .resources.telemetry import AsyncTelemetryResource, TelemetryResource
+
+DEFAULT_BASE_URL = "http://127.0.0.1:8001"
+SDK_USER_AGENT = "omnesight-python-sdk/1.1.0"
+
+_STATUS_EXCEPTIONS = {
+    401: AuthenticationError,
+    403: AuthenticationError,
+    404: NotFoundError,
+    422: PolicyViolationError,
+    429: RateLimitError,
+}
+
+
+def _resolve_client_settings(
+    api_key: str | None,
+    base_url: str | None,
+) -> tuple[str, str, dict[str, str]]:
+    """Resolve API credentials, gateway base URL, and standard Omnesight headers."""
+    resolved_key = api_key or os.environ.get("OMNESIGHT_API_KEY")
+    if not resolved_key:
+        raise AuthenticationError(
+            "API key must be provided or set via OMNESIGHT_API_KEY environment variable."
+        )
+    env_url = os.environ.get("OMNESIGHT_BASE_URL")
+    resolved_url = (base_url or env_url or DEFAULT_BASE_URL).rstrip("/")
+    headers = {
+        "Authorization": f"Bearer {resolved_key}",
+        "X-API-Key": resolved_key,
+        "Content-Type": "application/json",
+        "User-Agent": SDK_USER_AGENT,
+    }
+    return resolved_key, resolved_url, headers
+
+
+def _parse_response(response: httpx.Response) -> dict[str, Any]:
+    """Decode successful JSON payloads or raise the typed Omnesight SDK exception."""
+    if 200 <= response.status_code < 300:
+        return response.json()
+
+    error_msg = response.text
+    try:
+        error_data = response.json()
+        error_msg = error_data.get("message", error_data.get("detail", error_msg))
+    except ValueError:
+        error_msg = response.text
+
+    exc_cls = _STATUS_EXCEPTIONS.get(response.status_code, InternalServerError)
+    raise exc_cls(error_msg, status_code=response.status_code)
+
+
+class Omnesight:
+    """Synchronous enterprise client for Omnesight Sovereign MLOps Infrastructure."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        transport: httpx.BaseTransport | None = None,
+    ):
+        resolved = _resolve_client_settings(api_key, base_url)
+        self.api_key, self.base_url, headers = resolved
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+        client_kwargs: dict[str, Any] = {
+            "base_url": self.base_url,
+            "headers": headers,
+            "timeout": self.timeout,
+        }
+        if transport is not None:
+            client_kwargs["transport"] = transport
+        self._http_client = httpx.Client(**client_kwargs)
+
+        self.telemetry = TelemetryResource(self)
+        self.reconciliation = ReconciliationResource(self)
+        self.actions = ActionsResource(self)
+        self.hackmalim = HackmalimResource(self)
+        self.sandalfon = SandalfonResource(self)
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = self._http_client.request(method, path, **kwargs)
+                return _parse_response(resp)
+            except httpx.TransportError as exc:
+                if attempt == self.max_retries:
+                    msg = f"Connection to Omnesight infrastructure failed: {exc}"
+                    raise InternalServerError(msg) from exc
+        raise OmnesightError("Request failed after retries.")
+
+    def close(self):
+        self._http_client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class AsyncOmnesight:
+    """Asynchronous enterprise client for Omnesight Sovereign MLOps Infrastructure."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ):
+        resolved = _resolve_client_settings(api_key, base_url)
+        self.api_key, self.base_url, headers = resolved
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+        client_kwargs: dict[str, Any] = {
+            "base_url": self.base_url,
+            "headers": headers,
+            "timeout": self.timeout,
+        }
+        if transport is not None:
+            client_kwargs["transport"] = transport
+        self._http_client = httpx.AsyncClient(**client_kwargs)
+
+        self.telemetry = AsyncTelemetryResource(self)
+        self.reconciliation = AsyncReconciliationResource(self)
+        self.actions = AsyncActionsResource(self)
+        self.hackmalim = AsyncHackmalimResource(self)
+        self.sandalfon = AsyncSandalfonResource(self)
+
+    async def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = await self._http_client.request(method, path, **kwargs)
+                return _parse_response(resp)
+            except httpx.TransportError as exc:
+                if attempt == self.max_retries:
+                    msg = f"Connection to Omnesight infrastructure failed: {exc}"
+                    raise InternalServerError(msg) from exc
+        raise OmnesightError("Request failed after retries.")
+
+    async def aclose(self):
+        await self._http_client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()

omnesight/exceptions.py

@@ -0,0 +1,31 @@
+"""
+Omnesight SDK Exceptions
+"""
+
+class OmnesightError(Exception):
+    """Base exception for all Omnesight SDK errors."""
+    def __init__(self, message: str, status_code: int = None, details: dict = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.details = details or {}
+
+class AuthenticationError(OmnesightError):
+    """Raised when the provided API key or cryptographic token is invalid or expired."""
+    pass
+
+class PolicyViolationError(OmnesightError):
+    """Raised when an action violates enterprise governance, policy limits, or requires escalation."""
+    pass
+
+class RateLimitError(OmnesightError):
+    """Raised when telemetry throughput exceeds contracted tier rate limits."""
+    pass
+
+class NotFoundError(OmnesightError):
+    """Raised when a requested entity, pipeline, or action does not exist."""
+    pass
+
+class InternalServerError(OmnesightError):
+    """Raised when the sovereign backend encounters an unhandled infrastructure error."""
+    pass

omnesight/models.py

@@ -0,0 +1,157 @@
+"""
+Omnesight SDK Models & Schemas (Pydantic v2)
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class TelemetryRecord(BaseModel):
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    device_id: str
+    metric: str
+    value: float
+    unit: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class TelemetryIngestResponse(BaseModel):
+    batch_id: str
+    records_received: int
+    records_committed: int
+    duration_ms: float
+    status: str
+
+
+class DiscrepancyReport(BaseModel):
+    discrepancy_id: str
+    entity_a_type: str
+    entity_a_id: str
+    entity_b_type: str
+    entity_b_id: str
+    variance_amount_usd: float
+    variance_pct: float
+    status: str
+    detected_at: datetime
+    recommended_action_id: str | None = None
+
+
+class ActionApprovalRequest(BaseModel):
+    action_id: str
+    action_type: str
+    target_entity: str
+    decision: str  # "APPROVE" | "REJECT" | "MODIFIED"
+    supervisor_id: str
+    supervisor_notes: str | None = None
+
+
+class ActionStatusResponse(BaseModel):
+    action_id: str
+    state: str  # "PROPOSED", "SUPERVISED_APPROVAL", "COMMITTED", "REVERTED"
+    action_type: str
+    financial_impact_usd: float
+    sha256_audit_hash: str
+    executed_at: datetime | None = None
+
+
+class HackmalimInferRequest(BaseModel):
+    """Request payload for Hackmalim v1.0 closed-loop 3-layer inference."""
+
+    shock_amplitude: float = Field(default=1.45, ge=0.0, le=5.0)
+    jitter_severity: float = Field(default=1.0, ge=0.0, le=2.0)
+    inlet_n0: float = Field(default=60.0, ge=10.0, le=150.0)
+    inlet_n1: float = Field(default=50.0, ge=10.0, le=150.0)
+    leak_node: int = Field(default=2, ge=1, le=5)
+    leak_magnitude: float = Field(default=22.5, ge=0.0, le=50.0)
+    p_max_kw: float = Field(default=55.0, ge=10.0, le=200.0)
+    t_max_c: float = Field(default=72.0, ge=30.0, le=130.0)
+    autonomous_budget_usd: float = Field(default=4200.0, ge=0.0, le=1_000_000.0)
+
+
+class HackmalimInferResponse(BaseModel):
+    """Closed-loop response from Hackmalim v1.0 sovereign inference."""
+
+    model_config = ConfigDict(extra="allow")
+
+    model: str
+    version: str
+    latency_ms: float | None = None
+    inference_latency_ms: float | None = None
+    computed_stress_z: float | None = None
+    target_entity_id: str | None = None
+    liquid_ode: dict[str, Any] | None = None
+    stage_1_liquid_ode: dict[str, Any] | None = None
+    pignn: dict[str, Any] | None = None
+    stage_2_pignn: dict[str, Any] | None = None
+    causal: dict[str, Any] | None = None
+    stage_3_causal_symbolic: dict[str, Any] | None = None
+    action_policy: dict[str, Any] | None = None
+    guardrails: dict[str, Any] | None = None
+    enterprise_guardrail: dict[str, Any] | None = None
+
+
+class SandalfonDiscoverRequest(BaseModel):
+    """Request payload for Sandalfon v1.0 SINDy + FFT + Popperian discovery."""
+
+    preset: Literal[
+        "coupled_oscillator",
+        "predator_prey_grid",
+        "thermal_runaway",
+    ] = "coupled_oscillator"
+    noise_level: float = Field(default=0.02, ge=0.0, le=0.20)
+    sparsity_threshold: float = Field(default=0.10, ge=0.001, le=1.0)
+    precursor_amp: float = Field(default=0.18, ge=0.0, le=1.0)
+    hypothesis_text: str | None = Field(default=None, max_length=1000)
+
+
+class SandalfonDiscoverResponse(BaseModel):
+    """Response payload with discovered ODEs, FFT spectrum, and Popperian p-value."""
+
+    model_config = ConfigDict(extra="allow")
+
+    model: str
+    version: str
+    latency_ms: float
+    hypothesis_text: str
+    sindy: dict[str, Any]
+    spectrum: dict[str, Any]
+    hypothesis_test: dict[str, Any]
+    discovery_proof_sha256: str
+
+
+class SandalfonChatRequest(BaseModel):
+    """Conversational scientific research hypothesis payload for Sandalfon v1.0."""
+
+    message: str = Field(..., min_length=1, max_length=2000)
+    preset: Literal[
+        "coupled_oscillator",
+        "predator_prey_grid",
+        "thermal_runaway",
+    ] = "coupled_oscillator"
+    noise_level: float = Field(default=0.02, ge=0.0, le=0.20)
+    sparsity_threshold: float = Field(default=0.10, ge=0.001, le=1.0)
+    precursor_amp: float = Field(default=0.18, ge=0.0, le=1.0)
+
+
+class SandalfonChatResponse(BaseModel):
+    """Structured scientific response with spoken explanation and verified SINDy run."""
+
+    model_config = ConfigDict(extra="allow")
+
+    model: str
+    version: str
+    query: str | None = None
+    preset_used: str | None = None
+    parameters_used: dict[str, Any] | None = None
+    applied_controls: dict[str, Any] | None = None
+    spoken_reply: str
+    voice_lang: str | None = "fr-FR"
+    experiment: dict[str, Any] | None = None
+    sindy: dict[str, Any] | None = None
+    spectrum: dict[str, Any] | None = None
+    hypothesis_test: dict[str, Any] | None = None
+    discovery_proof_sha256: str | None = None

omnesight/resources/__init__.py

@@ -0,0 +1,18 @@
+from .actions import ActionsResource, AsyncActionsResource
+from .hackmalim import AsyncHackmalimResource, HackmalimResource
+from .reconciliation import AsyncReconciliationResource, ReconciliationResource
+from .sandalfon import AsyncSandalfonResource, SandalfonResource
+from .telemetry import AsyncTelemetryResource, TelemetryResource
+
+__all__ = [
+    "ActionsResource",
+    "AsyncActionsResource",
+    "AsyncHackmalimResource",
+    "AsyncReconciliationResource",
+    "AsyncSandalfonResource",
+    "AsyncTelemetryResource",
+    "HackmalimResource",
+    "ReconciliationResource",
+    "SandalfonResource",
+    "TelemetryResource",
+]

omnesight/resources/actions.py

@@ -0,0 +1,37 @@
+"""
+Supervised Action Protocol (SAP) Resource
+Governs automated policy execution with cryptographic provenance.
+"""
+
+from typing import Dict, Any, Optional
+from ..models import ActionApprovalRequest, ActionStatusResponse
+
+class ActionsResource:
+    def __init__(self, client):
+        self._client = client
+
+    def get_status(self, action_id: str) -> ActionStatusResponse:
+        """
+        Retrieve state, cryptographic SHA-256 hash, and execution log of an action.
+        """
+        res = self._client._request("GET", f"/api/v1/actions/{action_id}")
+        return ActionStatusResponse(**res)
+
+    def submit_decision(self, approval: ActionApprovalRequest) -> ActionStatusResponse:
+        """
+        Submit a human supervisor decision (APPROVE, REJECT, MODIFIED) for a staged action.
+        """
+        res = self._client._request("POST", f"/api/v1/actions/{approval.action_id}/decision", json=approval.model_dump())
+        return ActionStatusResponse(**res)
+
+class AsyncActionsResource:
+    def __init__(self, client):
+        self._client = client
+
+    async def get_status(self, action_id: str) -> ActionStatusResponse:
+        res = await self._client._request("GET", f"/api/v1/actions/{action_id}")
+        return ActionStatusResponse(**res)
+
+    async def submit_decision(self, approval: ActionApprovalRequest) -> ActionStatusResponse:
+        res = await self._client._request("POST", f"/api/v1/actions/{approval.action_id}/decision", json=approval.model_dump())
+        return ActionStatusResponse(**res)

omnesight/resources/hackmalim.py

@@ -0,0 +1,194 @@
+"""
+Hackmalim v1.0 Sovereign Non-LLM Engine Resource
+Continuous-Time Liquid Neural ODE + Physics-Informed GNN + Causal SAT Verifier.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models import HackmalimInferRequest, HackmalimInferResponse
+
+
+class HackmalimResource:
+    """Synchronous client resource for Hackmalim v1.0."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def info(self) -> dict[str, Any]:
+        """Retrieve Hackmalim v1.0 model card, parameter counts, and layer metrics."""
+        return self._client._request("GET", "/api/v1/hackmalim/info")
+
+    def infer(
+        self,
+        shock_amplitude: float = 1.45,
+        jitter_severity: float = 1.0,
+        inlet_n0: float = 60.0,
+        inlet_n1: float = 50.0,
+        leak_node: int = 2,
+        leak_magnitude: float = 22.5,
+        p_max_kw: float = 55.0,
+        t_max_c: float = 72.0,
+        autonomous_budget_usd: float = 4200.0,
+    ) -> HackmalimInferResponse:
+        """Run full closed-loop 3-layer inference with EnterpriseGuardrailsEngine."""
+        req = HackmalimInferRequest(
+            shock_amplitude=shock_amplitude,
+            jitter_severity=jitter_severity,
+            inlet_n0=inlet_n0,
+            inlet_n1=inlet_n1,
+            leak_node=leak_node,
+            leak_magnitude=leak_magnitude,
+            p_max_kw=p_max_kw,
+            t_max_c=t_max_c,
+            autonomous_budget_usd=autonomous_budget_usd,
+        )
+        res = self._client._request(
+            "POST", "/api/v1/hackmalim/infer", json=req.model_dump()
+        )
+        return HackmalimInferResponse(**res)
+
+    def liquid(
+        self,
+        shock_idx: int = 160,
+        shock_amplitude: float = 1.45,
+        jitter_severity: float = 1.0,
+    ) -> dict[str, Any]:
+        """Run Layer 1 Continuous-Time Liquid Neural ODE shock detection."""
+        payload = {
+            "shock_idx": shock_idx,
+            "shock_amplitude": shock_amplitude,
+            "jitter_severity": jitter_severity,
+        }
+        return self._client._request("POST", "/api/v1/hackmalim/liquid", json=payload)
+
+    def pignn(
+        self,
+        inlet_n0: float = 60.0,
+        inlet_n1: float = 50.0,
+        leak_node: int = 2,
+        leak_magnitude: float = 22.5,
+    ) -> dict[str, Any]:
+        """Run Layer 2 Kirchhoff PI-GNN flow reconstruction and leak pinpointing."""
+        payload = {
+            "inlet_n0": inlet_n0,
+            "inlet_n1": inlet_n1,
+            "leak_node": leak_node,
+            "leak_magnitude": leak_magnitude,
+        }
+        return self._client._request("POST", "/api/v1/hackmalim/pignn", json=payload)
+
+    def causal(
+        self,
+        z_load_shift: float = 0.0,
+        stress_z: float = 0.95,
+        p_max_kw: float = 55.0,
+        t_max_c: float = 72.0,
+        neural_proposal: tuple[int, int, int, int] | None = None,
+    ) -> dict[str, Any]:
+        """Run Layer 3 Pearl Do-Calculus backdoor adjustment and SAT axiom verifier."""
+        payload: dict[str, Any] = {
+            "z_load_shift": z_load_shift,
+            "stress_z": stress_z,
+            "p_max_kw": p_max_kw,
+            "t_max_c": t_max_c,
+        }
+        if neural_proposal is not None:
+            payload["neural_proposal"] = list(neural_proposal)
+        return self._client._request("POST", "/api/v1/hackmalim/causal", json=payload)
+
+
+class AsyncHackmalimResource:
+    """Asynchronous client resource for Hackmalim v1.0."""
+
+    def __init__(self, client):
+        self._client = client
+
+    async def info(self) -> dict[str, Any]:
+        """Retrieve Hackmalim v1.0 model card asynchronously."""
+        return await self._client._request("GET", "/api/v1/hackmalim/info")
+
+    async def infer(
+        self,
+        shock_amplitude: float = 1.45,
+        jitter_severity: float = 1.0,
+        inlet_n0: float = 60.0,
+        inlet_n1: float = 50.0,
+        leak_node: int = 2,
+        leak_magnitude: float = 22.5,
+        p_max_kw: float = 55.0,
+        t_max_c: float = 72.0,
+        autonomous_budget_usd: float = 4200.0,
+    ) -> HackmalimInferResponse:
+        """Run closed-loop 3-layer Hackmalim inference asynchronously."""
+        req = HackmalimInferRequest(
+            shock_amplitude=shock_amplitude,
+            jitter_severity=jitter_severity,
+            inlet_n0=inlet_n0,
+            inlet_n1=inlet_n1,
+            leak_node=leak_node,
+            leak_magnitude=leak_magnitude,
+            p_max_kw=p_max_kw,
+            t_max_c=t_max_c,
+            autonomous_budget_usd=autonomous_budget_usd,
+        )
+        res = await self._client._request(
+            "POST", "/api/v1/hackmalim/infer", json=req.model_dump()
+        )
+        return HackmalimInferResponse(**res)
+
+    async def liquid(
+        self,
+        shock_idx: int = 160,
+        shock_amplitude: float = 1.45,
+        jitter_severity: float = 1.0,
+    ) -> dict[str, Any]:
+        """Run Layer 1 Liquid ODE inference asynchronously."""
+        payload = {
+            "shock_idx": shock_idx,
+            "shock_amplitude": shock_amplitude,
+            "jitter_severity": jitter_severity,
+        }
+        return await self._client._request(
+            "POST", "/api/v1/hackmalim/liquid", json=payload
+        )
+
+    async def pignn(
+        self,
+        inlet_n0: float = 60.0,
+        inlet_n1: float = 50.0,
+        leak_node: int = 2,
+        leak_magnitude: float = 22.5,
+    ) -> dict[str, Any]:
+        """Run Layer 2 PI-GNN inference asynchronously."""
+        payload = {
+            "inlet_n0": inlet_n0,
+            "inlet_n1": inlet_n1,
+            "leak_node": leak_node,
+            "leak_magnitude": leak_magnitude,
+        }
+        return await self._client._request(
+            "POST", "/api/v1/hackmalim/pignn", json=payload
+        )
+
+    async def causal(
+        self,
+        z_load_shift: float = 0.0,
+        stress_z: float = 0.95,
+        p_max_kw: float = 55.0,
+        t_max_c: float = 72.0,
+        neural_proposal: tuple[int, int, int, int] | None = None,
+    ) -> dict[str, Any]:
+        """Run Layer 3 Pearl Do-Calculus + SAT verifier asynchronously."""
+        payload: dict[str, Any] = {
+            "z_load_shift": z_load_shift,
+            "stress_z": stress_z,
+            "p_max_kw": p_max_kw,
+            "t_max_c": t_max_c,
+        }
+        if neural_proposal is not None:
+            payload["neural_proposal"] = list(neural_proposal)
+        return await self._client._request(
+            "POST", "/api/v1/hackmalim/causal", json=payload
+        )

omnesight/resources/reconciliation.py

@@ -0,0 +1,45 @@
+"""
+ERP vs Ledger Closed-Loop Reconciliation Resource
+"""
+
+from typing import List, Dict, Any, Optional
+from ..models import DiscrepancyReport
+
+class ReconciliationResource:
+    def __init__(self, client):
+        self._client = client
+
+    def scan_discrepancies(
+        self,
+        erp_system: str = "SAP",
+        entity_type: str = "PURCHASE_ORDERS",
+        lookback_days: int = 7
+    ) -> List[DiscrepancyReport]:
+        """
+        Trigger reconciliation scan across enterprise ERP and telemetry ledgers.
+        """
+        params = {
+            "erp_system": erp_system,
+            "entity_type": entity_type,
+            "lookback_days": lookback_days
+        }
+        res = self._client._request("GET", "/api/v1/reconciliation/discrepancies", params=params)
+        return [DiscrepancyReport(**item) for item in res.get("discrepancies", [])]
+
+class AsyncReconciliationResource:
+    def __init__(self, client):
+        self._client = client
+
+    async def scan_discrepancies(
+        self,
+        erp_system: str = "SAP",
+        entity_type: str = "PURCHASE_ORDERS",
+        lookback_days: int = 7
+    ) -> List[DiscrepancyReport]:
+        params = {
+            "erp_system": erp_system,
+            "entity_type": entity_type,
+            "lookback_days": lookback_days
+        }
+        res = await self._client._request("GET", "/api/v1/reconciliation/discrepancies", params=params)
+        return [DiscrepancyReport(**item) for item in res.get("discrepancies", [])]

omnesight/resources/sandalfon.py

@@ -0,0 +1,123 @@
+"""
+Sandalfon v1.0 Scientific Equation Discovery & Spectral AI Engine Resource
+SINDy Sparse Discovery (STLSQ) + FFT Spectral Precursor Explorer + Popperian Test.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from ..models import (
+    SandalfonChatRequest,
+    SandalfonChatResponse,
+    SandalfonDiscoverRequest,
+    SandalfonDiscoverResponse,
+)
+
+SandalfonPreset = Literal["coupled_oscillator", "predator_prey_grid", "thermal_runaway"]
+
+
+class SandalfonResource:
+    """Synchronous client resource for Sandalfon v1.0."""
+
+    def __init__(self, client):
+        self._client = client
+
+    def info(self) -> dict[str, Any]:
+        """Retrieve Sandalfon v1.0 model card and candidate monomial library."""
+        return self._client._request("GET", "/api/v1/sandalfon/info")
+
+    def discover(
+        self,
+        preset: SandalfonPreset = "coupled_oscillator",
+        noise_level: float = 0.02,
+        sparsity_threshold: float = 0.10,
+        precursor_amp: float = 0.18,
+        hypothesis_text: str | None = None,
+    ) -> SandalfonDiscoverResponse:
+        """Discover sparse ODEs, FFT wave precursors, and Popperian significance."""
+        req = SandalfonDiscoverRequest(
+            preset=preset,
+            noise_level=noise_level,
+            sparsity_threshold=sparsity_threshold,
+            precursor_amp=precursor_amp,
+            hypothesis_text=hypothesis_text,
+        )
+        res = self._client._request(
+            "POST", "/api/v1/sandalfon/discover", json=req.model_dump()
+        )
+        return SandalfonDiscoverResponse(**res)
+
+    def chat(
+        self,
+        message: str,
+        preset: SandalfonPreset = "coupled_oscillator",
+        noise_level: float = 0.02,
+        sparsity_threshold: float = 0.10,
+        precursor_amp: float = 0.18,
+    ) -> SandalfonChatResponse:
+        """Interact in natural language with Sandalfon to test hypotheses."""
+        req = SandalfonChatRequest(
+            message=message,
+            preset=preset,
+            noise_level=noise_level,
+            sparsity_threshold=sparsity_threshold,
+            precursor_amp=precursor_amp,
+        )
+        res = self._client._request(
+            "POST", "/api/v1/sandalfon/chat", json=req.model_dump()
+        )
+        return SandalfonChatResponse(**res)
+
+
+class AsyncSandalfonResource:
+    """Asynchronous client resource for Sandalfon v1.0."""
+
+    def __init__(self, client):
+        self._client = client
+
+    async def info(self) -> dict[str, Any]:
+        """Retrieve Sandalfon v1.0 model card asynchronously."""
+        return await self._client._request("GET", "/api/v1/sandalfon/info")
+
+    async def discover(
+        self,
+        preset: SandalfonPreset = "coupled_oscillator",
+        noise_level: float = 0.02,
+        sparsity_threshold: float = 0.10,
+        precursor_amp: float = 0.18,
+        hypothesis_text: str | None = None,
+    ) -> SandalfonDiscoverResponse:
+        """Discover sparse ODEs and spectral precursors asynchronously."""
+        req = SandalfonDiscoverRequest(
+            preset=preset,
+            noise_level=noise_level,
+            sparsity_threshold=sparsity_threshold,
+            precursor_amp=precursor_amp,
+            hypothesis_text=hypothesis_text,
+        )
+        res = await self._client._request(
+            "POST", "/api/v1/sandalfon/discover", json=req.model_dump()
+        )
+        return SandalfonDiscoverResponse(**res)
+
+    async def chat(
+        self,
+        message: str,
+        preset: SandalfonPreset = "coupled_oscillator",
+        noise_level: float = 0.02,
+        sparsity_threshold: float = 0.10,
+        precursor_amp: float = 0.18,
+    ) -> SandalfonChatResponse:
+        """Query Sandalfon research dialogue asynchronously."""
+        req = SandalfonChatRequest(
+            message=message,
+            preset=preset,
+            noise_level=noise_level,
+            sparsity_threshold=sparsity_threshold,
+            precursor_amp=precursor_amp,
+        )
+        res = await self._client._request(
+            "POST", "/api/v1/sandalfon/chat", json=req.model_dump()
+        )
+        return SandalfonChatResponse(**res)

omnesight/resources/telemetry.py

@@ -0,0 +1,33 @@
+"""
+Telemetry Ingestion & Stream Resource
+"""
+
+from typing import List, Union, Dict, Any
+from ..models import TelemetryRecord, TelemetryIngestResponse
+
+class TelemetryResource:
+    def __init__(self, client):
+        self._client = client
+
+    def ingest(self, stream_id: str, records: List[Union[TelemetryRecord, Dict[str, Any]]]) -> TelemetryIngestResponse:
+        """
+        Ingest a batch of operational telemetry records into Omnesight real-time pipelines.
+        """
+        payload = {
+            "stream_id": stream_id,
+            "records": [r.model_dump() if isinstance(r, TelemetryRecord) else r for r in records]
+        }
+        res = self._client._request("POST", "/api/v1/telemetry/ingest", json=payload)
+        return TelemetryIngestResponse(**res)
+
+class AsyncTelemetryResource:
+    def __init__(self, client):
+        self._client = client
+
+    async def ingest(self, stream_id: str, records: List[Union[TelemetryRecord, Dict[str, Any]]]) -> TelemetryIngestResponse:
+        payload = {
+            "stream_id": stream_id,
+            "records": [r.model_dump() if isinstance(r, TelemetryRecord) else r for r in records]
+        }
+        res = await self._client._request("POST", "/api/v1/telemetry/ingest", json=payload)
+        return TelemetryIngestResponse(**res)

omnesight-1.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.5
+Name: omnesight
+Version: 1.1.0
+Summary: Official Python SDK for Omnesight Sovereign Operational Intelligence & Autonomous Execution Infrastructure
+Project-URL: Homepage, https://omnesight.com
+Project-URL: Documentation, https://omnesight.com/docs
+Project-URL: Repository, https://github.com/Omnesight/omnesight-python
+Project-URL: Security Policy, https://github.com/Omnesight/.github/blob/main/SECURITY.md
+Author-email: Omnesight Infrastructure Team <solutions@omnesight.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: autonomous-execution,enterprise-ai,erp-reconciliation,omnesight,operational-intelligence,sovereign-ai,telemetry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: typing-extensions>=4.8.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# Omnesight Python SDK
+
+**The official Python client library for Omnesight Sovereign Operational Intelligence & Autonomous Execution Infrastructure.**
+
+[![PyPI version](https://img.shields.io/badge/pypi-v1.1.0-blue.svg?style=flat-square)](https://pypi.org/project/omnesight/)
+[![Python Versions](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue?style=flat-square)](https://pypi.org/project/omnesight/)
+[![License](https://img.shields.io/badge/license-Apache--2.0-green.svg?style=flat-square)](LICENSE)
+[![Security Policy](https://img.shields.io/badge/security-SLA%20%3C24h-blueviolet.svg?style=flat-square)](https://github.com/Omnesight/.github/blob/main/SECURITY.md)
+
+[Website](https://omnesight.com) • [Documentation](https://omnesight.com/docs) • [Security & Compliance](https://github.com/Omnesight/.github/blob/main/SECURITY.md) • [Support](https://github.com/Omnesight/.github/blob/main/SUPPORT.md)
+
+</div>
+
+---
+
+## Overview
+
+The **Omnesight Python SDK** provides typed access to Omnesight's sovereign Non-LLM scientific engines (**Hackmalim v1.0**, **Sandalfon v1.0**) alongside enterprise operational intelligence gateways:
+
+* **Hackmalim v1.0 (`client.hackmalim`):** 3-layer Non-LLM control combining Continuous-Time Liquid Neural ODEs, Kirchhoff Physics-Informed GNNs, and Pearl Do-Calculus + SAT Axiom Verification.
+* **Sandalfon v1.0 (`client.sandalfon`):** Sparse differential equation discovery (SINDy/STLSQ), FFT spectral wave precursor extraction, and Popperian permutation falsification.
+* **Ingest Multi-Source Telemetry:** Stream telemetry from SCADA, IoT sensors, GPS fleets, and warehouse terminals in sub-second latency.
+* **Closed-Loop ERP Reconciliation:** Automatically detect and resolve transactional variances across SAP S/4HANA, Oracle NetSuite, Microsoft Dynamics 365, and financial ledgers.
+* **Supervised Action Protocol (SAP):** Execute automated operational interventions under deterministic governance policies and cryptographic audit trails.
+
+---
+
+## Installation
+
+```bash
+pip install omnesight
+```
+
+---
+
+## Quickstart
+
+### 1. Sovereign Scientific & Control Engines (`Hackmalim` & `Sandalfon`)
+
+```python
+from omnesight import Omnesight
+
+# Reads OMNESIGHT_API_KEY and OMNESIGHT_BASE_URL (defaults to http://127.0.0.1:8001)
+client = Omnesight(
+    api_key="omne_live_your_secret_key",
+    base_url="https://mlops-api.omnesight.com",
+)
+
+# Sandalfon v1.0: Extract sparse ODEs + spectral FFT wave precursors
+discovery = client.sandalfon.discover(
+    preset="thermal_runaway",
+    noise_level=0.02,
+    sparsity_threshold=0.10,
+    precursor_amp=0.18,
+    hypothesis_text="Cable thermal overload precursor detection",
+)
+print(discovery.sindy["discovered_eq_x"], discovery.hypothesis_test["z_score"])
+
+dialogue = client.sandalfon.chat(
+    message="Analyse les précurseurs thermiques sur les câbles",
+    preset="thermal_runaway",
+)
+print(dialogue.spoken_reply)
+
+# Hackmalim v1.0: Closed-loop Liquid ODE + PI-GNN + Causal SAT Verifier
+res = client.hackmalim.infer(
+    shock_amplitude=1.45,
+    leak_node=2,
+    leak_magnitude=22.5,
+    p_max_kw=55.0,
+    t_max_c=72.0,
+)
+print(res.target_entity_id, res.enterprise_guardrail)
+```
+
+### 2. Synchronous Enterprise Telemetry Client
+
+```python
+from omnesight import Omnesight
+
+# Initialize the client (reads OMNESIGHT_API_KEY & OMNESIGHT_BASE_URL from environment if omitted)
+client = Omnesight(
+    api_key="your_api_key_here",
+    base_url="https://omnesight.internal.company.com" # Your private VPC or dedicated sovereign gateway
+)
+
+# 1. Ingest asset telemetry
+response = client.telemetry.ingest(
+    stream_id="freight-corridor-lagos-kano",
+    records=[
+        {
+            "device_id": "TRUCK-GPS-104",
+            "metric": "cargo_seal_integrity",
+            "value": 1.0,
+            "metadata": {"driver": "ID-992", "cargo": "Refined Petroleum"}
+        }
+    ]
+)
+print(f"Batch {response.batch_id} ingested in {response.duration_ms}ms")
+
+# 2. Scan ERP vs Ledger Discrepancies
+discrepancies = client.reconciliation.scan_discrepancies(
+    erp_system="SAP",
+    entity_type="PURCHASE_ORDERS",
+    lookback_days=7
+)
+
+for d in discrepancies:
+    print(f"Discrepancy #{d.discrepancy_id}: Variance ${d.variance_amount_usd:,.2f} ({d.status})")
+```
+
+---
+
+### 2. Asynchronous Client (AsyncIO / High Concurrency)
+
+For data engineering pipelines or FastAPI backends handling thousands of events per second:
+
+```python
+import asyncio
+from omnesight import AsyncOmnesight
+
+async def main():
+    async with AsyncOmnesight(api_key="your_api_key_here") as client:
+        response = await client.telemetry.ingest(
+            stream_id="scada-compressor-alpha",
+            records=[
+                {"device_id": "CMP-01", "metric": "vibration_hz", "value": 44.2}
+            ]
+        )
+        print(f"Ingested batch: {response.batch_id}")
+
+asyncio.run(main())
+```
+
+---
+
+## Enterprise VPC & Sovereign Deployments
+
+For single-tenant institutional customers running Omnesight within a private VPC (AWS, Azure, GCP, Alibaba Cloud) or air-gapped on-premise Kubernetes cluster:
+
+```python
+client = Omnesight(
+    api_key="your_sovereign_vpc_token",
+    base_url="https://omnesight.internal.company.com", # Private VPC endpoint
+    timeout=60.0
+)
+```
+
+---
+
+## Supervised Action Protocol (SAP)
+
+Automated write-backs to core ERPs and ledger reconciliations require policy validation:
+
+```python
+from omnesight.models import ActionApprovalRequest
+
+# Retrieve status of an automated action staged by the cognitive engine
+action = client.actions.get_status("ACT-88492")
+print(f"Action: {action.action_type} | Impact: ${action.financial_impact_usd} | State: {action.state}")
+
+# Submit human-in-the-loop supervisor approval
+client.actions.submit_decision(ActionApprovalRequest(
+    action_id="ACT-88492",
+    action_type="ERP_LEDGER_WRITE",
+    target_entity="PO-77189",
+    decision="APPROVE",
+    supervisor_id="SUP-MAV-01",
+    supervisor_notes="Validated with physical bill of lading #BL-9921"
+))
+```
+
+---
+
+## Security & Data Sovereignty
+
+* **Zero Frontier Model Training:** Omnesight never ingests customer transactional payloads or telemetry into public foundation model weights.
+* **Cryptographic Traceability:** Every staged action is signed with a SHA-256 audit hash.
+* **Security Advisories:** For vulnerability disclosure, see [SECURITY.md](https://github.com/Omnesight/.github/blob/main/SECURITY.md) or email `security@omnesight.com`.
+
+---
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) for details.

omnesight-1.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+omnesight/__init__.py,sha256=6zsBLaNYZDnfIb3Fstyi-qMMW4gviuScFWrQ2U52yiI,909
+omnesight/client.py,sha256=tBt30PcUsk5SMhKlNw0Z0Xa-MWkVwaUcydFtLT5CyGA,6183
+omnesight/exceptions.py,sha256=ubJy--dgR9d9V4MkCHbjfDmol117pqDWZgdIUXiv-wM,1043
+omnesight/models.py,sha256=YuexEUx3fgPhVWezIXedpECBElOwYt4z5Bl6hcVShEc,4935
+omnesight/resources/__init__.py,sha256=2gwMu3qv3--o0cD30FXs6YfViI5z22jdTmDDmbMMgwA,630
+omnesight/resources/actions.py,sha256=zRKvYTl8CefoIvk2pF4h7atMwv4x2ascvqLnq8Z-2L4,1524
+omnesight/resources/hackmalim.py,sha256=GI-fVTv6WTvduCJE1__ho_AWYavz10M45AdcnP_L3fM,6522
+omnesight/resources/reconciliation.py,sha256=zX2WSROs3gKe6IyGkjxPillu5BN1veJeQRZg8R-iMis,1489
+omnesight/resources/sandalfon.py,sha256=xf3ycx4S1A7FgMbGFCMPMiYwIYThJrPNXZBjTDvi2w4,4157
+omnesight/resources/telemetry.py,sha256=yUd9XGt8Nbp1qH6hAdTteruXSG-Mi0EP4z2V1ZhDfHQ,1294
+omnesight-1.1.0.dist-info/METADATA,sha256=qhw9HKtej1-jVbB-RwwdntYGRJaY9ctR-qP1JvFvAuc,8163
+omnesight-1.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+omnesight-1.1.0.dist-info/licenses/LICENSE,sha256=_uDRmBuozFO_P59gE4FF11cdRMujChrEloTCIaGelnM,4513
+omnesight-1.1.0.dist-info/RECORD,,

omnesight-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

omnesight-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,87 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to use, reproduce, modify, display, perform,
+      sublicense, and distribute the Work and such Derivative Works.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      patent license to make, have made, use, sell, offer to sell,
+      import, and otherwise transfer the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, provided that You meet the following conditions:
+      (a) You must give any other recipients of the Work a copy of this License; and
+      (b) You must cause any modified files to carry prominent notices stating
+          that You changed the files; and
+      (c) You must retain, in the Source form of any Derivative Works, all
+          copyright, patent, trademark, and attribution notices from the Source form.
+
+   Copyright 2026 Omnesight
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.