auros-protocol 1.0.0__py3-none-any.whl

auros/__init__.py

@@ -0,0 +1,6 @@
+"""AUROS Protocol Python SDK."""
+
+from auros.client import AurosProtocol, AurosProtocolError
+
+__all__ = ["AurosProtocol", "AurosProtocolError"]
+__version__ = "1.0.0"

auros/client.py

@@ -0,0 +1,136 @@
+"""AUROS Protocol HTTP client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+DEFAULT_BASE_URL = "https://getauros.com"
+
+
+class AurosProtocolError(Exception):
+    def __init__(self, code: str, message: str, status: int) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.status = status
+
+
+class AurosProtocol:
+    """Typed client for the AUROS Protocol REST API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        client: httpx.Client | None = None,
+    ) -> None:
+        if not api_key or not api_key.strip():
+            raise ValueError("api_key is required")
+        self._api_key = api_key.strip()
+        self._base_url = base_url.rstrip("/")
+        self._client = client or httpx.Client(timeout=30.0)
+        self._owns_client = client is None
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> AurosProtocol:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def score(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/score", body)
+
+    def score_batch(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/score/batch", body)
+
+    def score_history(self, score_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/score/{score_id}/history")
+
+    def products(self, **query: Any) -> dict[str, Any]:
+        return self._get("/api/v1/products", query)
+
+    def jurisdictions(self, **query: Any) -> dict[str, Any]:
+        return self._get("/api/v1/jurisdictions", query)
+
+    def checklist(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/checklist", body)
+
+    def compare(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/compare", body)
+
+    def status(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/status", auth=False)
+
+    def monitor(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/monitor", body)
+
+    def get_monitor(self, monitor_id: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/monitor/{monitor_id}")
+
+    def delete_monitor(self, monitor_id: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/v1/monitor/{monitor_id}")
+
+    def dossier(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/dossier", body)
+
+    def register_webhook(self, **body: Any) -> dict[str, Any]:
+        return self._post("/api/v1/webhooks", body)
+
+    def webhooks(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/webhooks")
+
+    def delete_webhook(self, webhook_id: str) -> dict[str, Any]:
+        return self._request("DELETE", f"/api/v1/webhooks/{webhook_id}")
+
+    def create_key(self, email: str) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/keys", json={"email": email}, auth=False)
+
+    def _get(self, path: str, params: dict[str, Any]) -> dict[str, Any]:
+        filtered = {k: v for k, v in params.items() if v is not None}
+        return self._request("GET", path, params=filtered)
+
+    def _post(self, path: str, body: dict[str, Any]) -> dict[str, Any]:
+        filtered = {k: v for k, v in body.items() if v is not None}
+        return self._request("POST", path, json=filtered)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        auth: bool = True,
+    ) -> dict[str, Any]:
+        headers: dict[str, str] = {
+            "Accept": "application/json",
+            "X-AUROS-Protocol-Version": "1.0",
+        }
+        if json is not None:
+            headers["Content-Type"] = "application/json"
+        if auth:
+            headers["Authorization"] = f"Bearer {self._api_key}"
+
+        response = self._client.request(
+            method,
+            f"{self._base_url}{path}",
+            headers=headers,
+            json=json,
+            params=params,
+        )
+        data = response.json()
+        if not response.is_success:
+            err = data.get("error", {}) if isinstance(data, dict) else {}
+            raise AurosProtocolError(
+                err.get("code", "unknown_error"),
+                err.get("message", "Request failed"),
+                response.status_code,
+            )
+        return data

auros_protocol-1.0.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: auros-protocol
+Version: 1.0.0
+Summary: Official Python SDK for the AUROS Protocol — RWA intelligence API
+Project-URL: Homepage, https://getauros.com/developers
+Project-URL: Documentation, https://getauros.com/developers/docs
+Project-URL: Repository, https://github.com/getauros/auros
+Author-email: AUROS <contact@getauros.com>
+License-Expression: MIT
+Keywords: api,auros,mica,rwa,tokenization
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# auros-protocol (Python)
+
+Official Python SDK for the [AUROS Protocol](https://getauros.com/developers).
+
+## Install
+
+```bash
+pip install auros-protocol
+```
+
+Or from source:
+
+```bash
+cd packages/auros-protocol-python
+pip install -e .
+```
+
+## Quickstart
+
+```python
+from auros import AurosProtocol
+
+client = AurosProtocol(api_key="auros_pk_test_demo")
+
+result = client.score(
+    description="Retail warehouse Luxembourg €2.5M SPV professional investors"
+)
+print(result["score"], result["grade"], result["mica_classification"])
+```
+
+## Methods
+
+| Method | Endpoint | Auth |
+|--------|----------|------|
+| `score(**fields)` | `POST /api/v1/score` | Bearer |
+| `score_batch(**body)` | `POST /api/v1/score/batch` | Bearer |
+| `products(**query)` | `GET /api/v1/products` | Bearer |
+| `jurisdictions(**query)` | `GET /api/v1/jurisdictions` | Bearer |
+| `checklist(**body)` | `POST /api/v1/checklist` | Bearer |
+| `compare(**body)` | `POST /api/v1/compare` | Bearer |
+| `status()` | `GET /api/v1/status` | None |
+| `create_key(email)` | `POST /api/v1/keys` | None |
+
+## Examples
+
+```python
+# Catalog
+bonds = client.products(category="bonds", yield_min=4, limit=10)
+
+# Jurisdictions
+ranking = client.jurisdictions(
+    asset_type="real_estate",
+    investor_type="professional",
+    timeline_months=6,
+)
+
+# Checklist
+items = client.checklist(
+    asset_type="real_estate",
+    jurisdiction="luxembourg",
+    structure="spv",
+)
+
+# Compare RWA products
+comparison = client.compare(category="bonds", yield_min=4, limit=3)
+
+# API health (no auth)
+health = client.status()
+print(health["status"], health["version"])
+
+# Free API key
+key_resp = client.create_key("you@company.com")
+print(key_resp["api_key"])
+```
+
+## Context manager
+
+```python
+with AurosProtocol(api_key="auros_pk_test_demo") as client:
+    print(client.score(description="..."))
+```
+
+## Disclaimer
+
+Indicative intelligence only — not legal, tax, or investment advice.
+
+## Publish (maintainers)
+
+```bash
+cd packages/auros-protocol-python
+python -m pip install --upgrade build twine
+python -m build
+python -m twine upload dist/*
+```
+
+Set `TWINE_USERNAME=__token__` and `TWINE_PASSWORD=pypi-<your-api-token>` before upload.

auros_protocol-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+auros/__init__.py,sha256=hiDLdd2ciDa7Gj9WDnUkCUqbNEAIzt1cGJTpzmnOcdE,172
+auros/client.py,sha256=5IJyYvDr-EdQ2w5xcPFLCh-8Aso9ua8Grac3Nh-rnQ4,4634
+auros/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auros_protocol-1.0.0.dist-info/METADATA,sha256=38kU1TqBs8OrlgN5f7B60F70PJGg5Qv3PA0nXDho-x4,3061
+auros_protocol-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+auros_protocol-1.0.0.dist-info/RECORD,,

auros_protocol-1.0.0.dist-info/WHEEL

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