aethex 0.1.0__tar.gz

aethex-0.1.0/PKG-INFO

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: aethex
+Version: 0.1.0
+Summary: Official Python SDK for Aethex — multi-domain AI threat verification (cyber, finance, LLM safety) with explainable reasoning chains.
+Author-email: Aethex <lizsanchez@aethexai.net>
+License: MIT
+Project-URL: Homepage, https://github.com/aethexa1/aethexai
+Project-URL: Documentation, https://github.com/aethexa1/aethexai/tree/main/docs
+Project-URL: Repository, https://github.com/aethexa1/aethexai
+Project-URL: Issues, https://github.com/aethexa1/aethexai/issues
+Keywords: ai-safety,threat-detection,llm-safety,cybersecurity,fraud-detection,aml,fatf,mitre-attack,explainable-ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+
+# Aethex Python SDK
+
+Official Python client for [Aethex](https://github.com/aethexa1/aethexai) —
+a multi-domain AI threat verification API with explainable reasoning chains.
+
+Aethex runs threat events through 10 deterministic reasoning engines and
+returns a verdict with severity, confidence, and a traceable reasoning
+chain. Same engines work across three product domains:
+
+- **Cyber** — SOC alerts, intrusion patterns, insider threats
+- **Finance** — AML, sanctions screening, FATF typologies
+- **LLM safety** — agent failure modes, prompt injection, tool-use exfiltration
+
+Verdicts are deterministic. Same input produces the same output every
+time, with the same audit trail. This is the core differentiator vs
+LLM-only detection systems.
+
+## Install
+
+```bash
+pip install aethex
+```
+
+No external dependencies. Pure stdlib (urllib, json).
+
+## Quick start
+
+```python
+from aethex import AethexClient
+
+client = AethexClient(api_key="aex_live_...")
+
+# Cyber threat analysis
+verdict = client.cyber.analyze(events=[
+    {"type": "failed_login"},
+    {"type": "failed_login"},
+    {"type": "successful_login", "suspicious": True},
+    {"type": "privilege_escalation", "suspicious": True},
+    {"type": "lateral_movement", "suspicious": True},
+])
+
+print(verdict["final_severity"])    # CRITICAL
+print(verdict["final_confidence"])  # 0.92
+print(verdict["verdict"])           # human-readable summary
+```
+
+## Three product domains
+
+```python
+# Cyber
+client.cyber.analyze(events=[...])
+
+# Finance (AML / sanctions / fraud)
+client.finance.analyze(events=[
+    {"type": "ofac_full_match", "suspicious": True},
+    {"type": "sanctioned_geography_routing", "suspicious": True},
+])
+
+# LLM safety
+client.llm.analyze(events=[
+    {"type": "external_document_retrieval"},
+    {"type": "instruction_override_detected", "suspicious": True},
+    {"type": "tool_use_data_exfiltration", "suspicious": True},
+])
+
+# Discover the canonical LLM event vocabulary
+mapping = client.llm.vocabulary()
+```
+
+## Account operations
+
+```python
+# Audit log export (compliance)
+audit = client.account.export_audit(format="json", from_="2026-01-01")
+
+# Customer-tunable severity weighting
+client.account.replace_loss_matrix({
+    "failed_login":      0.5,   # downweight noisy events
+    "external_transfer": 5.0,   # upweight critical events
+})
+
+# Webhooks for real-time alerts
+webhook = client.account.create_webhook(
+    url="https://your-app.com/aethex-webhook",
+    threshold="CRITICAL",
+)
+# Save webhook["secret"] now -- it's shown only once.
+
+deliveries = client.account.list_deliveries(webhook["id"])
+```
+
+## Error handling
+
+```python
+from aethex import (
+    AethexAuthError,
+    AethexRateLimitError,
+    AethexValidationError,
+    AethexConnectionError,
+    AethexError,
+)
+
+try:
+    verdict = client.cyber.analyze(events=[...])
+except AethexAuthError:
+    # 401 — bad / missing / revoked API key
+    ...
+except AethexRateLimitError:
+    # 429 — back off and retry
+    ...
+except AethexValidationError as e:
+    # 400 — request body malformed
+    print(e.response)
+except AethexConnectionError:
+    # network / timeout / DNS / SSL
+    ...
+except AethexError:
+    # catch-all for anything Aethex-related
+    ...
+```
+
+## What you get back
+
+Every `analyze` call returns a verdict dict with:
+
+- `final_severity` — `LOW` / `MEDIUM` / `HIGH` / `CRITICAL`
+- `final_confidence` — 0.0 to 1.0
+- `verdict` — human-readable summary
+- `action` — recommended operational response
+- `engines` — per-engine outputs from all 10 reasoning engines
+- `nyaya` — the formal reasoning chain that produced the verdict
+- `chakravyuha` — defense-in-depth layers breached
+- `disagreement` — when engines disagree, the system surfaces uncertainty
+  rather than producing false confidence
+
+See the [API documentation](https://github.com/aethexa1/aethexai)
+for the full verdict shape.
+
+## Configuration
+
+```python
+client = AethexClient(
+    api_key="aex_live_...",
+    base_url="https://aethex-api-1yqe.onrender.com",  # default
+    timeout=30,                                       # seconds
+)
+```
+
+## Status
+
+Alpha. APIs are stabilizing. Breaking changes possible until 1.0.
+
+## License
+
+MIT. See LICENSE for details.
+
+---
+
+Built by Aethex. Questions: open an issue at the
+[GitHub repo](https://github.com/aethexa1/aethexai/issues).

aethex-0.1.0/README.md

@@ -0,0 +1,160 @@
+# Aethex Python SDK
+
+Official Python client for [Aethex](https://github.com/aethexa1/aethexai) —
+a multi-domain AI threat verification API with explainable reasoning chains.
+
+Aethex runs threat events through 10 deterministic reasoning engines and
+returns a verdict with severity, confidence, and a traceable reasoning
+chain. Same engines work across three product domains:
+
+- **Cyber** — SOC alerts, intrusion patterns, insider threats
+- **Finance** — AML, sanctions screening, FATF typologies
+- **LLM safety** — agent failure modes, prompt injection, tool-use exfiltration
+
+Verdicts are deterministic. Same input produces the same output every
+time, with the same audit trail. This is the core differentiator vs
+LLM-only detection systems.
+
+## Install
+
+```bash
+pip install aethex
+```
+
+No external dependencies. Pure stdlib (urllib, json).
+
+## Quick start
+
+```python
+from aethex import AethexClient
+
+client = AethexClient(api_key="aex_live_...")
+
+# Cyber threat analysis
+verdict = client.cyber.analyze(events=[
+    {"type": "failed_login"},
+    {"type": "failed_login"},
+    {"type": "successful_login", "suspicious": True},
+    {"type": "privilege_escalation", "suspicious": True},
+    {"type": "lateral_movement", "suspicious": True},
+])
+
+print(verdict["final_severity"])    # CRITICAL
+print(verdict["final_confidence"])  # 0.92
+print(verdict["verdict"])           # human-readable summary
+```
+
+## Three product domains
+
+```python
+# Cyber
+client.cyber.analyze(events=[...])
+
+# Finance (AML / sanctions / fraud)
+client.finance.analyze(events=[
+    {"type": "ofac_full_match", "suspicious": True},
+    {"type": "sanctioned_geography_routing", "suspicious": True},
+])
+
+# LLM safety
+client.llm.analyze(events=[
+    {"type": "external_document_retrieval"},
+    {"type": "instruction_override_detected", "suspicious": True},
+    {"type": "tool_use_data_exfiltration", "suspicious": True},
+])
+
+# Discover the canonical LLM event vocabulary
+mapping = client.llm.vocabulary()
+```
+
+## Account operations
+
+```python
+# Audit log export (compliance)
+audit = client.account.export_audit(format="json", from_="2026-01-01")
+
+# Customer-tunable severity weighting
+client.account.replace_loss_matrix({
+    "failed_login":      0.5,   # downweight noisy events
+    "external_transfer": 5.0,   # upweight critical events
+})
+
+# Webhooks for real-time alerts
+webhook = client.account.create_webhook(
+    url="https://your-app.com/aethex-webhook",
+    threshold="CRITICAL",
+)
+# Save webhook["secret"] now -- it's shown only once.
+
+deliveries = client.account.list_deliveries(webhook["id"])
+```
+
+## Error handling
+
+```python
+from aethex import (
+    AethexAuthError,
+    AethexRateLimitError,
+    AethexValidationError,
+    AethexConnectionError,
+    AethexError,
+)
+
+try:
+    verdict = client.cyber.analyze(events=[...])
+except AethexAuthError:
+    # 401 — bad / missing / revoked API key
+    ...
+except AethexRateLimitError:
+    # 429 — back off and retry
+    ...
+except AethexValidationError as e:
+    # 400 — request body malformed
+    print(e.response)
+except AethexConnectionError:
+    # network / timeout / DNS / SSL
+    ...
+except AethexError:
+    # catch-all for anything Aethex-related
+    ...
+```
+
+## What you get back
+
+Every `analyze` call returns a verdict dict with:
+
+- `final_severity` — `LOW` / `MEDIUM` / `HIGH` / `CRITICAL`
+- `final_confidence` — 0.0 to 1.0
+- `verdict` — human-readable summary
+- `action` — recommended operational response
+- `engines` — per-engine outputs from all 10 reasoning engines
+- `nyaya` — the formal reasoning chain that produced the verdict
+- `chakravyuha` — defense-in-depth layers breached
+- `disagreement` — when engines disagree, the system surfaces uncertainty
+  rather than producing false confidence
+
+See the [API documentation](https://github.com/aethexa1/aethexai)
+for the full verdict shape.
+
+## Configuration
+
+```python
+client = AethexClient(
+    api_key="aex_live_...",
+    base_url="https://aethex-api-1yqe.onrender.com",  # default
+    timeout=30,                                       # seconds
+)
+```
+
+## Status
+
+Alpha. APIs are stabilizing. Breaking changes possible until 1.0.
+
+## License
+
+MIT. See LICENSE for details.
+
+---
+
+Built by Aethex. Questions: open an issue at the
+[GitHub repo](https://github.com/aethexa1/aethexai/issues).

aethex-0.1.0/aethex/__init__.py

@@ -0,0 +1,51 @@
+"""
+Aethex Python SDK.
+
+Quick start:
+
+    from aethex import AethexClient
+
+    client = AethexClient(api_key="aex_live_...")
+
+    verdict = client.cyber.analyze(events=[
+        {"type": "failed_login"},
+        {"type": "successful_login", "suspicious": True},
+        {"type": "privilege_escalation", "suspicious": True},
+    ])
+
+    print(verdict["final_severity"])
+
+Three product domains: cyber, finance, llm.
+Account operations on client.account.
+
+Full docs: https://github.com/aethexa1/aethexai
+"""
+
+from ._version import __version__
+
+from .client import AethexClient
+
+from .exceptions import (
+    AethexError,
+    AethexAuthError,
+    AethexConnectionError,
+    AethexNotFoundError,
+    AethexPermissionError,
+    AethexRateLimitError,
+    AethexServerError,
+    AethexValidationError,
+)
+
+
+__all__ = [
+    "__version__",
+    "AethexClient",
+    "AethexError",
+    "AethexAuthError",
+    "AethexConnectionError",
+    "AethexNotFoundError",
+    "AethexPermissionError",
+    "AethexRateLimitError",
+    "AethexServerError",
+    "AethexValidationError",
+]

aethex-0.1.0/aethex/_version.py

@@ -0,0 +1,15 @@
+"""
+Aethex Python SDK — single source of truth for version number.
+
+Imported by setup.py / pyproject.toml at build time, and by
+aethex/__init__.py at runtime so customers can introspect the
+SDK version they have installed (`aethex.__version__`).
+
+Bump on every PyPI release. Pre-1.0 follows 0.x.y where:
+  - x bumps for breaking changes (rare pre-1.0)
+  - y bumps for new features and bug fixes
+
+Post-1.0 we'll switch to strict semver.
+"""
+
+__version__ = "0.1.0"

aethex-0.1.0/aethex/client.py

@@ -0,0 +1,348 @@
+"""
+Aethex Python SDK — main client.
+
+Provides AethexClient: a unified interface to all three product
+domains (cyber, finance, llm) plus account-level operations
+(audit export, loss matrix, webhooks).
+
+Usage:
+    from aethex import AethexClient
+
+    client = AethexClient(api_key="aex_live_...")
+
+    # Cyber analysis
+    verdict = client.cyber.analyze(events=[
+        {"type": "failed_login"},
+        {"type": "successful_login", "suspicious": True},
+        {"type": "privilege_escalation", "suspicious": True},
+    ])
+    print(verdict["final_severity"])  # e.g. "CRITICAL"
+
+    # Finance analysis
+    verdict = client.finance.analyze(events=[
+        {"type": "ofac_full_match", "suspicious": True},
+        {"type": "sanctioned_geography_routing", "suspicious": True},
+    ])
+
+    # LLM safety analysis
+    verdict = client.llm.analyze(events=[
+        {"type": "external_document_retrieval"},
+        {"type": "instruction_override_detected", "suspicious": True},
+        {"type": "tool_use_data_exfiltration", "suspicious": True},
+    ])
+
+Implementation notes:
+  - Pure stdlib HTTP (urllib). No external dependencies. Customers
+    don't need to pip install requests just to use Aethex.
+  - One client instance is thread-safe for read-only attribute access
+    but should be created once and reused, not constructed per call.
+  - Default timeout: 30 seconds. Configurable per client or per call.
+  - All API errors map to typed exceptions in aethex.exceptions.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from ._version  import __version__
+from .exceptions import (
+    AethexAuthError,
+    AethexConnectionError,
+    AethexError,
+    AethexNotFoundError,
+    AethexPermissionError,
+    AethexRateLimitError,
+    AethexServerError,
+    AethexValidationError,
+)
+
+
+# ─── defaults ──────────────────────────────────────────────
+
+DEFAULT_BASE_URL = "https://aethex-api-1yqe.onrender.com"
+DEFAULT_TIMEOUT  = 30
+USER_AGENT       = f"aethex-python/{__version__}"
+
+
+# ─── http core ─────────────────────────────────────────────
+
+def _raise_for_status(status: int, body: str) -> None:
+    """Map an HTTP status code to a typed AethexError."""
+    if status == 401:
+        raise AethexAuthError(
+            "API key invalid, missing, or revoked.",
+            status_code=status, response=body,
+        )
+    if status == 403:
+        raise AethexPermissionError(
+            "API key not scoped for this product domain.",
+            status_code=status, response=body,
+        )
+    if status == 404:
+        raise AethexNotFoundError(
+            "Resource not found.",
+            status_code=status, response=body,
+        )
+    if status == 429:
+        raise AethexRateLimitError(
+            "Rate limit exceeded.",
+            status_code=status, response=body,
+        )
+    if status == 400 or 405 <= status < 500:
+        raise AethexValidationError(
+            f"Request rejected ({status}): {body[:200]}",
+            status_code=status, response=body,
+        )
+    if 500 <= status < 600:
+        raise AethexServerError(
+            f"Aethex server error ({status}).",
+            status_code=status, response=body,
+        )
+    # Other unexpected status -- still surface it.
+    raise AethexError(
+        f"Unexpected HTTP {status}: {body[:200]}",
+        status_code=status, response=body,
+    )
+
+
+# ─── client ────────────────────────────────────────────────
+
+class AethexClient:
+    """
+    Main entry point for the Aethex SDK.
+
+    Args:
+        api_key:   your aex_live_... key (required)
+        base_url:  override the API endpoint (defaults to production)
+        timeout:   per-request timeout in seconds (default 30)
+    """
+
+    def __init__(
+        self,
+        api_key:  str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout:  int = DEFAULT_TIMEOUT,
+    ):
+        if not api_key or not isinstance(api_key, str):
+            raise ValueError("api_key must be a non-empty string")
+        if not api_key.startswith("aex_"):
+            raise ValueError(
+                "api_key has invalid format (expected to start with 'aex_')"
+            )
+
+        self._api_key  = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout  = timeout
+
+        # Sub-clients for each product domain
+        self.cyber   = _CyberAPI(self)
+        self.finance = _FinanceAPI(self)
+        self.llm     = _LLMAPI(self)
+
+        # Account-level operations
+        self.account = _AccountAPI(self)
+
+    # ─── internal HTTP ────────────────────────────────────
+
+    def _request(
+        self,
+        method:   str,
+        path:     str,
+        body:     Optional[Dict[str, Any]] = None,
+        timeout:  Optional[int]            = None,
+    ) -> Dict[str, Any]:
+        """
+        Internal HTTP helper. Customers should not call this directly --
+        use the typed methods on cyber/finance/llm/account instead.
+        """
+        url     = self._base_url + path
+        timeout = timeout or self._timeout
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "User-Agent":    USER_AGENT,
+            "Accept":        "application/json",
+        }
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        req = Request(url, data=data, method=method, headers=headers)
+
+        try:
+            with urlopen(req, timeout=timeout) as resp:
+                response_body = resp.read().decode("utf-8")
+                if resp.status >= 400:
+                    _raise_for_status(resp.status, response_body)
+                return json.loads(response_body) if response_body else {}
+        except HTTPError as e:
+            response_body = ""
+            try:
+                response_body = e.read().decode("utf-8", errors="replace")
+            except Exception:
+                pass
+            _raise_for_status(e.code, response_body)
+            raise  # _raise_for_status always raises, but keep type checker happy
+        except URLError as e:
+            raise AethexConnectionError(
+                f"Network error reaching Aethex: {e.reason}"
+            ) from e
+        except Exception as e:
+            if isinstance(e, AethexError):
+                raise
+            raise AethexConnectionError(
+                f"Unexpected SDK error: {type(e).__name__}: {e}"
+            ) from e
+
+    # ─── repr ─────────────────────────────────────────────
+
+    def __repr__(self) -> str:
+        # Don't leak the API key in repr.
+        suffix = self._api_key[-4:] if self._api_key else "????"
+        return f"AethexClient(api_key=aex_live_***{suffix}, base_url={self._base_url!r})"
+
+
+# ─── sub-clients ───────────────────────────────────────────
+
+class _DomainAPI:
+    """Shared base for cyber/finance/llm domain sub-clients."""
+
+    _path = ""  # subclass override
+
+    def __init__(self, client: AethexClient):
+        self._client = client
+
+    def analyze(
+        self,
+        events:     List[Dict[str, Any]],
+        session_id: Optional[str]       = None,
+        timestamp:  Optional[str]       = None,
+        frames:     Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run a sequence of events through Aethex's 10 ancient engines.
+
+        Args:
+            events:     list of {"type": "...", "suspicious": bool} dicts
+            session_id: optional client-supplied session identifier
+            timestamp:  optional ISO 8601 timestamp (defaults to now)
+            frames:     optional list of perspective frames
+
+        Returns:
+            verdict dict containing final_severity, final_confidence,
+            engines (per-engine outputs), nyaya reasoning chain,
+            chakravyuha layers, and recommended action.
+        """
+        body: Dict[str, Any] = {"events": events}
+        if session_id is not None: body["session_id"] = session_id
+        if timestamp  is not None: body["timestamp"]  = timestamp
+        if frames     is not None: body["frames"]     = frames
+
+        return self._client._request("POST", f"{self._path}/analyze", body=body)
+
+
+class _CyberAPI(_DomainAPI):
+    """Cyber threat analysis. Use for SOC alerts, intrusion patterns, insider threats."""
+    _path = "/api/cyber"
+
+
+class _FinanceAPI(_DomainAPI):
+    """Financial fraud / AML / sanctions analysis."""
+    _path = "/api/finance"
+
+
+class _LLMAPI(_DomainAPI):
+    """LLM agent safety analysis. Translates LLM event types to engine vocabulary."""
+    _path = "/api/llm"
+
+    def vocabulary(self) -> Dict[str, Any]:
+        """
+        Return the canonical LLM event-type -> cyber-vocabulary
+        mapping. Useful for understanding which LLM events Aethex
+        recognizes and what their engine-level equivalents are.
+        """
+        return self._client._request("GET", "/api/llm/vocabulary")
+
+
+class _AccountAPI:
+    """Account-level operations: audit export, loss matrix, webhooks."""
+
+    def __init__(self, client: AethexClient):
+        self._client = client
+
+    # --- audit ---
+
+    def export_audit(
+        self,
+        format: str          = "json",
+        from_:  Optional[str] = None,
+        to:     Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Export the calling key's audit log.
+
+        Args:
+            format: "json" (default) or "csv"
+            from_:  ISO 8601 start (e.g. "2026-01-01")
+            to:     ISO 8601 end
+        """
+        params = []
+        if format: params.append(f"format={format}")
+        if from_:  params.append(f"from={from_}")
+        if to:     params.append(f"to={to}")
+        path = "/api/audit/export" + ("?" + "&".join(params) if params else "")
+        return self._client._request("GET", path)
+
+    # --- loss matrix ---
+
+    def get_loss_matrix(self) -> Dict[str, Any]:
+        """Return the calling key's current loss matrix."""
+        return self._client._request("GET", "/api/keys/me/loss-matrix")
+
+    def replace_loss_matrix(self, matrix: Dict[str, float]) -> Dict[str, Any]:
+        """Replace the entire loss matrix with the supplied dict."""
+        return self._client._request(
+            "PUT", "/api/keys/me/loss-matrix", body={"matrix": matrix},
+        )
+
+    def patch_loss_matrix(self, matrix: Dict[str, float]) -> Dict[str, Any]:
+        """Merge the supplied entries into the existing loss matrix."""
+        return self._client._request(
+            "PATCH", "/api/keys/me/loss-matrix", body={"matrix": matrix},
+        )
+
+    # --- webhooks ---
+
+    def list_webhooks(self) -> List[Dict[str, Any]]:
+        """List webhooks registered to the calling key."""
+        return self._client._request("GET", "/api/keys/me/webhooks")
+
+    def create_webhook(
+        self,
+        url:       str,
+        threshold: str = "CRITICAL",
+        name:      str = "default",
+    ) -> Dict[str, Any]:
+        """
+        Register a new webhook. The plaintext secret is returned ONCE
+        in the response. Save it immediately -- it is not retrievable
+        afterwards.
+        """
+        return self._client._request(
+            "POST", "/api/keys/me/webhooks",
+            body={"url": url, "threshold": threshold, "name": name},
+        )
+
+    def delete_webhook(self, webhook_id: int) -> Dict[str, Any]:
+        """Delete a webhook by id."""
+        return self._client._request(
+            "DELETE", f"/api/keys/me/webhooks/{webhook_id}",
+        )
+
+    def list_deliveries(self, webhook_id: int, limit: int = 50) -> List[Dict[str, Any]]:
+        """List recent delivery attempts for a webhook."""
+        return self._client._request(
+            "GET",
+            f"/api/keys/me/webhooks/{webhook_id}/deliveries?limit={limit}",
+        )

aethex-0.1.0/aethex/exceptions.py

@@ -0,0 +1,71 @@
+"""
+Aethex SDK — exception hierarchy.
+
+Customers catch these in their integration code. The hierarchy
+lets them either catch broadly (every Aethex error) or narrowly
+(only auth, only rate-limit, etc).
+
+  AethexError                       -- root; catch this for any SDK error
+    AethexAuthError                 -- 401: bad / missing / revoked API key
+    AethexPermissionError           -- 403: key not scoped for this product
+    AethexNotFoundError             -- 404: resource doesn't exist
+    AethexRateLimitError            -- 429: over rate limit
+    AethexValidationError           -- 400: malformed request
+    AethexServerError               -- 5xx: Aethex side broke
+    AethexConnectionError           -- network failure, timeout, DNS, SSL
+"""
+
+from typing import Optional
+
+
+class AethexError(Exception):
+    """
+    Base class for every error this SDK raises.
+    Carries the HTTP status code (if applicable) and the response
+    body returned by the Aethex API for debugging.
+    """
+
+    def __init__(
+        self,
+        message:     str,
+        status_code: Optional[int]  = None,
+        response:    Optional[str]  = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response    = response
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}("
+            f"message={str(self)!r}, "
+            f"status_code={self.status_code!r})"
+        )
+
+
+class AethexAuthError(AethexError):
+    """401 — API key missing, malformed, or revoked."""
+
+
+class AethexPermissionError(AethexError):
+    """403 — API key valid but not scoped for the requested product."""
+
+
+class AethexNotFoundError(AethexError):
+    """404 — resource (webhook, audit entry, etc) does not exist."""
+
+
+class AethexRateLimitError(AethexError):
+    """429 — over the per-key rate limit. Customer should back off."""
+
+
+class AethexValidationError(AethexError):
+    """400 — request body malformed (bad event types, missing fields)."""
+
+
+class AethexServerError(AethexError):
+    """5xx — Aethex side broke. Retry may help."""
+
+
+class AethexConnectionError(AethexError):
+    """Network-layer failure: timeout, DNS error, SSL error, connection refused."""

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

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: aethex
+Version: 0.1.0
+Summary: Official Python SDK for Aethex — multi-domain AI threat verification (cyber, finance, LLM safety) with explainable reasoning chains.
+Author-email: Aethex <lizsanchez@aethexai.net>
+License: MIT
+Project-URL: Homepage, https://github.com/aethexa1/aethexai
+Project-URL: Documentation, https://github.com/aethexa1/aethexai/tree/main/docs
+Project-URL: Repository, https://github.com/aethexa1/aethexai
+Project-URL: Issues, https://github.com/aethexa1/aethexai/issues
+Keywords: ai-safety,threat-detection,llm-safety,cybersecurity,fraud-detection,aml,fatf,mitre-attack,explainable-ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+
+# Aethex Python SDK
+
+Official Python client for [Aethex](https://github.com/aethexa1/aethexai) —
+a multi-domain AI threat verification API with explainable reasoning chains.
+
+Aethex runs threat events through 10 deterministic reasoning engines and
+returns a verdict with severity, confidence, and a traceable reasoning
+chain. Same engines work across three product domains:
+
+- **Cyber** — SOC alerts, intrusion patterns, insider threats
+- **Finance** — AML, sanctions screening, FATF typologies
+- **LLM safety** — agent failure modes, prompt injection, tool-use exfiltration
+
+Verdicts are deterministic. Same input produces the same output every
+time, with the same audit trail. This is the core differentiator vs
+LLM-only detection systems.
+
+## Install
+
+```bash
+pip install aethex
+```
+
+No external dependencies. Pure stdlib (urllib, json).
+
+## Quick start
+
+```python
+from aethex import AethexClient
+
+client = AethexClient(api_key="aex_live_...")
+
+# Cyber threat analysis
+verdict = client.cyber.analyze(events=[
+    {"type": "failed_login"},
+    {"type": "failed_login"},
+    {"type": "successful_login", "suspicious": True},
+    {"type": "privilege_escalation", "suspicious": True},
+    {"type": "lateral_movement", "suspicious": True},
+])
+
+print(verdict["final_severity"])    # CRITICAL
+print(verdict["final_confidence"])  # 0.92
+print(verdict["verdict"])           # human-readable summary
+```
+
+## Three product domains
+
+```python
+# Cyber
+client.cyber.analyze(events=[...])
+
+# Finance (AML / sanctions / fraud)
+client.finance.analyze(events=[
+    {"type": "ofac_full_match", "suspicious": True},
+    {"type": "sanctioned_geography_routing", "suspicious": True},
+])
+
+# LLM safety
+client.llm.analyze(events=[
+    {"type": "external_document_retrieval"},
+    {"type": "instruction_override_detected", "suspicious": True},
+    {"type": "tool_use_data_exfiltration", "suspicious": True},
+])
+
+# Discover the canonical LLM event vocabulary
+mapping = client.llm.vocabulary()
+```
+
+## Account operations
+
+```python
+# Audit log export (compliance)
+audit = client.account.export_audit(format="json", from_="2026-01-01")
+
+# Customer-tunable severity weighting
+client.account.replace_loss_matrix({
+    "failed_login":      0.5,   # downweight noisy events
+    "external_transfer": 5.0,   # upweight critical events
+})
+
+# Webhooks for real-time alerts
+webhook = client.account.create_webhook(
+    url="https://your-app.com/aethex-webhook",
+    threshold="CRITICAL",
+)
+# Save webhook["secret"] now -- it's shown only once.
+
+deliveries = client.account.list_deliveries(webhook["id"])
+```
+
+## Error handling
+
+```python
+from aethex import (
+    AethexAuthError,
+    AethexRateLimitError,
+    AethexValidationError,
+    AethexConnectionError,
+    AethexError,
+)
+
+try:
+    verdict = client.cyber.analyze(events=[...])
+except AethexAuthError:
+    # 401 — bad / missing / revoked API key
+    ...
+except AethexRateLimitError:
+    # 429 — back off and retry
+    ...
+except AethexValidationError as e:
+    # 400 — request body malformed
+    print(e.response)
+except AethexConnectionError:
+    # network / timeout / DNS / SSL
+    ...
+except AethexError:
+    # catch-all for anything Aethex-related
+    ...
+```
+
+## What you get back
+
+Every `analyze` call returns a verdict dict with:
+
+- `final_severity` — `LOW` / `MEDIUM` / `HIGH` / `CRITICAL`
+- `final_confidence` — 0.0 to 1.0
+- `verdict` — human-readable summary
+- `action` — recommended operational response
+- `engines` — per-engine outputs from all 10 reasoning engines
+- `nyaya` — the formal reasoning chain that produced the verdict
+- `chakravyuha` — defense-in-depth layers breached
+- `disagreement` — when engines disagree, the system surfaces uncertainty
+  rather than producing false confidence
+
+See the [API documentation](https://github.com/aethexa1/aethexai)
+for the full verdict shape.
+
+## Configuration
+
+```python
+client = AethexClient(
+    api_key="aex_live_...",
+    base_url="https://aethex-api-1yqe.onrender.com",  # default
+    timeout=30,                                       # seconds
+)
+```
+
+## Status
+
+Alpha. APIs are stabilizing. Breaking changes possible until 1.0.
+
+## License
+
+MIT. See LICENSE for details.
+
+---
+
+Built by Aethex. Questions: open an issue at the
+[GitHub repo](https://github.com/aethexa1/aethexai/issues).

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

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+setup.py
+aethex/__init__.py
+aethex/_version.py
+aethex/client.py
+aethex/exceptions.py
+aethex.egg-info/PKG-INFO
+aethex.egg-info/SOURCES.txt
+aethex.egg-info/dependency_links.txt
+aethex.egg-info/requires.txt
+aethex.egg-info/top_level.txt
+tests/test_client.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=7.0
+build>=1.0
+twine>=4.0

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

@@ -0,0 +1 @@
+aethex

aethex-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires      = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name            = "aethex"
+dynamic         = ["version"]
+description     = "Official Python SDK for Aethex — multi-domain AI threat verification (cyber, finance, LLM safety) with explainable reasoning chains."
+readme          = "README.md"
+requires-python = ">=3.8"
+license         = { text = "MIT" }
+authors         = [
+    { name = "Aethex", email = "lizsanchez@aethexai.net" }
+]
+keywords        = [
+    "ai-safety",
+    "threat-detection",
+    "llm-safety",
+    "cybersecurity",
+    "fraud-detection",
+    "aml",
+    "fatf",
+    "mitre-attack",
+    "explainable-ai",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+
+# No runtime dependencies. Pure stdlib (urllib, json).
+# Customers shouldn't need to install requests or httpx just to use Aethex.
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "build>=1.0",
+    "twine>=4.0",
+]
+
+[project.urls]
+Homepage      = "https://github.com/aethexa1/aethexai"
+Documentation = "https://github.com/aethexa1/aethexai/tree/main/docs"
+Repository    = "https://github.com/aethexa1/aethexai"
+Issues        = "https://github.com/aethexa1/aethexai/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["aethex*"]
+
+[tool.setuptools.dynamic]
+version = { attr = "aethex._version.__version__" }

aethex-0.1.0/setup.cfg

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

aethex-0.1.0/setup.py

@@ -0,0 +1,12 @@
+"""
+Aethex Python SDK — setup.py
+
+Modern packaging metadata lives in pyproject.toml. This file exists
+for legacy compatibility with build tools that still expect a
+setup.py to be present in the package root. setuptools will read
+the pyproject.toml automatically.
+"""
+
+from setuptools import setup
+
+setup()

aethex-0.1.0/tests/test_client.py

@@ -0,0 +1,171 @@
+"""
+Aethex SDK — basic tests.
+
+Run with:
+    cd sdk && pip install -e .[dev] && pytest tests/
+
+These are unit tests that don't hit the live API. They verify:
+  - Client construction validates inputs
+  - Exception mapping is correct for each HTTP status code
+  - The repr doesn't leak the API key
+
+Integration tests (which actually call the live API) live separately
+and require AETHEX_API_KEY to be set. See test_integration.py if it
+exists.
+"""
+
+import pytest
+
+from aethex import (
+    AethexClient,
+    AethexAuthError,
+    AethexConnectionError,
+    AethexError,
+    AethexNotFoundError,
+    AethexPermissionError,
+    AethexRateLimitError,
+    AethexServerError,
+    AethexValidationError,
+)
+from aethex.client import _raise_for_status
+
+
+# ─── client construction ──────────────────────────────────
+
+class TestClientConstruction:
+
+    def test_valid_key(self):
+        client = AethexClient(api_key="aex_live_test123")
+        assert client._api_key == "aex_live_test123"
+
+    def test_default_base_url(self):
+        client = AethexClient(api_key="aex_live_test123")
+        assert client._base_url == "https://aethex-api-1yqe.onrender.com"
+
+    def test_custom_base_url(self):
+        client = AethexClient(
+            api_key="aex_live_test123",
+            base_url="http://localhost:8000",
+        )
+        assert client._base_url == "http://localhost:8000"
+
+    def test_base_url_trailing_slash_stripped(self):
+        client = AethexClient(
+            api_key="aex_live_test123",
+            base_url="http://localhost:8000/",
+        )
+        assert client._base_url == "http://localhost:8000"
+
+    def test_empty_key_rejected(self):
+        with pytest.raises(ValueError, match="non-empty string"):
+            AethexClient(api_key="")
+
+    def test_none_key_rejected(self):
+        with pytest.raises(ValueError, match="non-empty string"):
+            AethexClient(api_key=None)
+
+    def test_non_string_key_rejected(self):
+        with pytest.raises(ValueError, match="non-empty string"):
+            AethexClient(api_key=12345)
+
+    def test_bad_format_key_rejected(self):
+        with pytest.raises(ValueError, match="invalid format"):
+            AethexClient(api_key="not_aethex_key")
+
+    def test_subclients_present(self):
+        client = AethexClient(api_key="aex_live_test123")
+        assert client.cyber   is not None
+        assert client.finance is not None
+        assert client.llm     is not None
+        assert client.account is not None
+
+
+class TestClientRepr:
+
+    def test_repr_does_not_leak_key(self):
+        """The repr must never include the full API key."""
+        client = AethexClient(api_key="aex_live_supersecret_dontleakme_abcdef")
+        r = repr(client)
+        assert "supersecret" not in r
+        assert "dontleakme"   not in r
+        # But the suffix is fine for debugging
+        assert "cdef" in r
+
+    def test_repr_includes_base_url(self):
+        client = AethexClient(
+            api_key="aex_live_test123",
+            base_url="http://localhost:8000",
+        )
+        assert "localhost:8000" in repr(client)
+
+
+# ─── exception mapping ────────────────────────────────────
+
+class TestExceptionMapping:
+
+    def test_401_raises_auth(self):
+        with pytest.raises(AethexAuthError) as exc:
+            _raise_for_status(401, '{"detail":"Invalid key"}')
+        assert exc.value.status_code == 401
+
+    def test_403_raises_permission(self):
+        with pytest.raises(AethexPermissionError):
+            _raise_for_status(403, '{"detail":"Wrong product"}')
+
+    def test_404_raises_not_found(self):
+        with pytest.raises(AethexNotFoundError):
+            _raise_for_status(404, '{"detail":"Webhook not found"}')
+
+    def test_429_raises_rate_limit(self):
+        with pytest.raises(AethexRateLimitError):
+            _raise_for_status(429, '{"detail":"Slow down"}')
+
+    def test_400_raises_validation(self):
+        with pytest.raises(AethexValidationError):
+            _raise_for_status(400, '{"detail":"Bad event"}')
+
+    def test_422_raises_validation(self):
+        """FastAPI returns 422 for Pydantic validation errors."""
+        with pytest.raises(AethexValidationError):
+            _raise_for_status(422, '{"detail":[{"msg":"field required"}]}')
+
+    def test_500_raises_server(self):
+        with pytest.raises(AethexServerError):
+            _raise_for_status(500, "Internal Server Error")
+
+    def test_502_raises_server(self):
+        with pytest.raises(AethexServerError):
+            _raise_for_status(502, "Bad Gateway")
+
+    def test_503_raises_server(self):
+        with pytest.raises(AethexServerError):
+            _raise_for_status(503, "Service Unavailable")
+
+
+# ─── exception class behavior ─────────────────────────────
+
+class TestExceptionClasses:
+
+    def test_all_inherit_from_aethex_error(self):
+        """Customers should be able to catch AethexError to catch any SDK error."""
+        for exc_cls in (
+            AethexAuthError,
+            AethexPermissionError,
+            AethexNotFoundError,
+            AethexRateLimitError,
+            AethexValidationError,
+            AethexServerError,
+            AethexConnectionError,
+        ):
+            assert issubclass(exc_cls, AethexError)
+
+    def test_carries_status_code(self):
+        e = AethexAuthError("test", status_code=401, response="body")
+        assert e.status_code == 401
+        assert e.response    == "body"
+
+    def test_repr_includes_class_name_and_status(self):
+        e = AethexAuthError("auth failed", status_code=401)
+        r = repr(e)
+        assert "AethexAuthError" in r
+        assert "401"             in r