aethellayer 0.1.0__tar.gz

aethellayer-0.1.0/.gitignore

@@ -0,0 +1,46 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+.venv/
+packages/python/dist/
+packages/python/*.egg-info/
+packages/sdk/dist/
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+!.env.example
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

aethellayer-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.5
+Name: aethellayer
+Version: 0.1.0
+Summary: AethelLayer probe for FastAPI, Starlette, and Python CLIs. Catch silent onboarding failures and open an inbox thread.
+Project-URL: Homepage, https://aethellayer.com
+Project-URL: Documentation, https://aethellayer.com
+Project-URL: Repository, https://github.com/aethellayer/aeth
+Author: AethelLayer
+License-Expression: MIT
+Keywords: aethellayer,developer-experience,fastapi,observability,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.110; extra == 'fastapi'
+Requires-Dist: starlette>=0.36; extra == 'fastapi'
+Description-Content-Type: text/markdown
+
+# aethellayer (Python)
+
+Probe for AethelLayer. Catch silent FastAPI, Starlette, Flask-style, and CLI failures.
+
+## Install
+
+```bash
+pip install aethellayer
+export AETHEL_API_KEY=aethel_live_...
+```
+
+## FastAPI
+
+```python
+from fastapi import FastAPI
+from aethellayer import Probe
+
+app = FastAPI()
+probe = Probe.from_env(environment="api_middleware", app_name="payments-api")
+app.add_middleware(probe.fastapi_middleware())
+```
+
+## Capture manually
+
+```python
+probe.capture(
+    error_code="RATE_LIMIT_429",
+    endpoint_path="GET /v1/keys",
+    taxonomy="RateLimit",
+    message="Starter quota burned before noon",
+)
+```
+
+## CLI
+
+```bash
+aethellayer init
+aethellayer run -- python your_cli.py
+```
+
+Or in code:
+
+```python
+from aethellayer import Probe
+
+with Probe.from_env(environment="cli").wrap_cli():
+    main()
+```
+
+## Publish (maintainers)
+
+```bash
+cd packages/python
+python -m pip install build twine
+python -m build
+python -m twine upload dist/*
+```

aethellayer-0.1.0/README.md

@@ -0,0 +1,57 @@
+# aethellayer (Python)
+
+Probe for AethelLayer. Catch silent FastAPI, Starlette, Flask-style, and CLI failures.
+
+## Install
+
+```bash
+pip install aethellayer
+export AETHEL_API_KEY=aethel_live_...
+```
+
+## FastAPI
+
+```python
+from fastapi import FastAPI
+from aethellayer import Probe
+
+app = FastAPI()
+probe = Probe.from_env(environment="api_middleware", app_name="payments-api")
+app.add_middleware(probe.fastapi_middleware())
+```
+
+## Capture manually
+
+```python
+probe.capture(
+    error_code="RATE_LIMIT_429",
+    endpoint_path="GET /v1/keys",
+    taxonomy="RateLimit",
+    message="Starter quota burned before noon",
+)
+```
+
+## CLI
+
+```bash
+aethellayer init
+aethellayer run -- python your_cli.py
+```
+
+Or in code:
+
+```python
+from aethellayer import Probe
+
+with Probe.from_env(environment="cli").wrap_cli():
+    main()
+```
+
+## Publish (maintainers)
+
+```bash
+cd packages/python
+python -m pip install build twine
+python -m build
+python -m twine upload dist/*
+```

aethellayer-0.1.0/aethellayer/__init__.py

@@ -0,0 +1,157 @@
+"""AethelLayer Python probe."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import traceback
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Callable, Mapping, MutableMapping, Optional
+
+DEFAULT_ENDPOINT = "https://api.aethellayer.com/v1/probes"
+
+
+@dataclass
+class Probe:
+    api_key: str
+    environment: str = "api_middleware"
+    endpoint: str = DEFAULT_ENDPOINT
+    app_name: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.api_key:
+            raise ValueError("Probe requires api_key (AETHEL_API_KEY)")
+
+    @classmethod
+    def from_env(cls, **kwargs: Any) -> "Probe":
+        key = kwargs.pop("api_key", None) or os.environ.get("AETHEL_API_KEY")
+        if not key:
+            raise ValueError("Set AETHEL_API_KEY or pass api_key=")
+        return cls(api_key=key, **kwargs)
+
+    def capture(
+        self,
+        *,
+        error_code: str,
+        message: Optional[str] = None,
+        stack: Optional[str] = None,
+        endpoint_path: Optional[str] = None,
+        taxonomy: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
+    ) -> dict[str, Any]:
+        body = {
+            "error_code": error_code,
+            "stack_trace": stack or message,
+            "endpoint_path": endpoint_path,
+            "taxonomy_category": taxonomy,
+            "environment": self.environment,
+            "app_name": self.app_name,
+            "metadata": {
+                "runtime": f"python {sys.version.split()[0]}",
+                **dict(self.metadata),
+                **dict(metadata or {}),
+            },
+        }
+        data = json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            self.endpoint,
+            data=data,
+            method="POST",
+            headers={
+                "content-type": "application/json",
+                "authorization": f"Bearer {self.api_key}",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=5) as res:
+                return {"ok": True, "status": getattr(res, "status", 200)}
+        except urllib.error.HTTPError as err:
+            return {"ok": False, "status": err.code}
+        except Exception as err:  # noqa: BLE001 - probe must never crash the host
+            return {"ok": False, "status": 0, "error": str(err)}
+
+    def capture_exception(
+        self,
+        exc: BaseException,
+        *,
+        error_code: str = "UNCAUGHT",
+        endpoint_path: Optional[str] = None,
+        taxonomy: str = "Uncaught",
+    ) -> dict[str, Any]:
+        return self.capture(
+            error_code=error_code,
+            message=str(exc),
+            stack="".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+            endpoint_path=endpoint_path,
+            taxonomy=taxonomy,
+        )
+
+    def fastapi_middleware(self):
+        """Starlette/FastAPI BaseHTTPMiddleware that captures 5xx responses."""
+        from starlette.middleware.base import BaseHTTPMiddleware
+        from starlette.requests import Request
+        from starlette.responses import Response
+
+        probe = self
+
+        class AethelMiddleware(BaseHTTPMiddleware):
+            async def dispatch(self, request: Request, call_next: Callable) -> Response:
+                try:
+                    response = await call_next(request)
+                except Exception as exc:  # noqa: BLE001
+                    probe.capture_exception(
+                        exc,
+                        error_code="UNCAUGHT_MIDDLEWARE",
+                        endpoint_path=f"{request.method} {request.url.path}",
+                    )
+                    raise
+                if response.status_code >= 500:
+                    probe.capture(
+                        error_code=f"HTTP_{response.status_code}",
+                        endpoint_path=f"{request.method} {request.url.path}",
+                        taxonomy="Http5xx",
+                    )
+                return response
+
+        return AethelMiddleware
+
+    def wrap_cli(self, argv: Optional[list[str]] = None):
+        """Context manager / decorator helper for CLI entrypoints."""
+        argv = argv or sys.argv
+        probe = self
+
+        class _Session:
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc, tb):
+                if exc is not None:
+                    probe.capture_exception(
+                        exc,
+                        error_code="CLI_FAILURE",
+                        endpoint_path=" ".join(argv),
+                        taxonomy="Cli",
+                    )
+                return False
+
+            def run(self, fn: Callable[[], Any]) -> Any:
+                try:
+                    return fn()
+                except Exception as exc:  # noqa: BLE001
+                    probe.capture_exception(
+                        exc,
+                        error_code="CLI_FAILURE",
+                        endpoint_path=" ".join(argv),
+                        taxonomy="Cli",
+                    )
+                    raise
+
+        return _Session()
+
+
+def probe(**kwargs: Any) -> Probe:
+    return Probe.from_env(**kwargs) if "api_key" not in kwargs else Probe(**kwargs)

aethellayer-0.1.0/aethellayer/cli.py

@@ -0,0 +1,62 @@
+"""CLI for the aethellayer Python package."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+
+from . import Probe
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="aethellayer", description="AethelLayer Python probe")
+    sub = parser.add_subparsers(dest="cmd")
+
+    sub.add_parser("init", help="Print install steps")
+    run = sub.add_parser("run", help="Wrap a command and capture non-zero exits")
+    run.add_argument("command", nargs=argparse.REMAINDER, help="Command after --")
+
+    args = parser.parse_args(argv)
+    if args.cmd == "init" or args.cmd is None:
+        print(
+            """AethelLayer Python init
+
+1. pip install aethellayer
+2. export AETHEL_API_KEY=aethel_live_...
+3. FastAPI:
+     from aethellayer import Probe
+     app.add_middleware(Probe.from_env(app_name="api").fastapi_middleware())
+4. CLI:
+     aethellayer run -- python your_cli.py
+
+Open the dashboard inbox after the first failure.
+"""
+        )
+        return
+
+    if args.cmd == "run":
+        command = [c for c in args.command if c != "--"]
+        if not command:
+            print("Usage: aethellayer run -- <command> [...args]", file=sys.stderr)
+            sys.exit(1)
+        api_key = os.environ.get("AETHEL_API_KEY")
+        if not api_key:
+            print("Missing AETHEL_API_KEY", file=sys.stderr)
+            sys.exit(1)
+        probe = Probe(api_key=api_key, environment="cli")
+        result = subprocess.run(command)
+        if result.returncode != 0:
+            probe.capture(
+                error_code=f"CLI_EXIT_{result.returncode}",
+                endpoint_path=" ".join(command),
+                taxonomy="Cli",
+            )
+        sys.exit(result.returncode)
+
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

aethellayer-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aethellayer"
+version = "0.1.0"
+description = "AethelLayer probe for FastAPI, Starlette, and Python CLIs. Catch silent onboarding failures and open an inbox thread."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "AethelLayer" }]
+keywords = ["aethellayer", "sdk", "observability", "fastapi", "developer-experience"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.optional-dependencies]
+fastapi = ["fastapi>=0.110", "starlette>=0.36"]
+dev = ["build", "twine"]
+
+[project.urls]
+Homepage = "https://aethellayer.com"
+Documentation = "https://aethellayer.com"
+Repository = "https://github.com/aethellayer/aeth"
+
+[project.scripts]
+aethellayer = "aethellayer.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["aethellayer"]