axlet 0.1.0__tar.gz

axlet-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+node_modules/
+.env
+.env.*
+!.env.example
+data/
+.tmp/
+artifacts/
+.vercel/
+dist/
+__pycache__/
+*.pyc
+supabase/.temp/

axlet-0.1.0/LICENSE

@@ -0,0 +1 @@
+All rights reserved. This release does not grant an open-source license.

axlet-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.5
+Name: axlet
+Version: 0.1.0
+Summary: Python client for the Axlet subscription and credits API
+Project-URL: Homepage, https://axlet.app
+License-Expression: LicenseRef-Proprietary
+License-File: LICENSE
+Keywords: axlet,credits,sdk,subscriptions
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Axlet Python SDK
+
+Server-side Python client for the Axlet subscription, entitlement, credits, and purchase APIs. Python 3.10 or later; no runtime dependencies.
+
+```sh
+pip install axlet
+```
+
+```python
+import os
+from axlet import AxletClient, AxletApiError
+
+client = AxletClient(
+    api_key=os.environ["AXLET_API_KEY"],
+    base_url=os.environ.get("AXLET_API_URL", "http://127.0.0.1:4310"),
+)
+print(client.get_plans())
+```
+
+Use an Axlet API server you operate or have access to. `axlet.app` is a website, not a hosted public API endpoint. This package does not include the API server. Keep operator API keys on your server.
+
+## Usage
+
+Methods use Python snake_case names. Input and response dictionaries preserve API camelCase fields:
+
+```python
+customer = client.create_customer(
+    {"name": "Example", "email": "user@example.com", "externalId": "user-123"},
+    idempotency_key="create-user-123",
+)
+access = client.get_access(customer["id"], "report")
+# For each paid operation, confirm successful consumption before doing the work.
+usage = client.consume_usage(
+    customer["id"],
+    {"feature": "report", "operationId": "report-job-123"},
+    idempotency_key="consume-job-123",
+)
+```
+
+Every mutation requires an idempotency key. Keys and operation IDs must contain 8–100 ASCII letters, digits, underscores, or hyphens. Reuse them only for retries of the same operation; generate new IDs for new work. The customer must have the required subscription or credits before consuming paid usage.
+
+Supported methods: `get_plans`, `set_plan`, `create_customer`, `register_billing`, `subscribe`, `cancel`, `refund`, `retry`, `get_entitlement`, `get_credits`, `get_access`, `consume_usage`, `cancel_usage`, `create_purchase`, `get_purchase`, `confirm_purchase`, `sync_purchase`, `refund_purchase`, `advance_demo`, and `run_jobs`.
+
+HTTP failures and invalid successful responses raise `AxletApiError` with `status` and `body`. Invalid keys raise `ValueError`. Network errors use the standard library's exceptions. Socket operations use a 75-second timeout, configurable with `timeout=`. Requests are synchronous, redirects are rejected, and no automatic retries are performed. Payment behavior depends on the API server configuration; installing this client does not enable production payments.
+
+## License
+
+All rights reserved. This release does not grant an open-source license.

axlet-0.1.0/README.md

@@ -0,0 +1,48 @@
+# Axlet Python SDK
+
+Server-side Python client for the Axlet subscription, entitlement, credits, and purchase APIs. Python 3.10 or later; no runtime dependencies.
+
+```sh
+pip install axlet
+```
+
+```python
+import os
+from axlet import AxletClient, AxletApiError
+
+client = AxletClient(
+    api_key=os.environ["AXLET_API_KEY"],
+    base_url=os.environ.get("AXLET_API_URL", "http://127.0.0.1:4310"),
+)
+print(client.get_plans())
+```
+
+Use an Axlet API server you operate or have access to. `axlet.app` is a website, not a hosted public API endpoint. This package does not include the API server. Keep operator API keys on your server.
+
+## Usage
+
+Methods use Python snake_case names. Input and response dictionaries preserve API camelCase fields:
+
+```python
+customer = client.create_customer(
+    {"name": "Example", "email": "user@example.com", "externalId": "user-123"},
+    idempotency_key="create-user-123",
+)
+access = client.get_access(customer["id"], "report")
+# For each paid operation, confirm successful consumption before doing the work.
+usage = client.consume_usage(
+    customer["id"],
+    {"feature": "report", "operationId": "report-job-123"},
+    idempotency_key="consume-job-123",
+)
+```
+
+Every mutation requires an idempotency key. Keys and operation IDs must contain 8–100 ASCII letters, digits, underscores, or hyphens. Reuse them only for retries of the same operation; generate new IDs for new work. The customer must have the required subscription or credits before consuming paid usage.
+
+Supported methods: `get_plans`, `set_plan`, `create_customer`, `register_billing`, `subscribe`, `cancel`, `refund`, `retry`, `get_entitlement`, `get_credits`, `get_access`, `consume_usage`, `cancel_usage`, `create_purchase`, `get_purchase`, `confirm_purchase`, `sync_purchase`, `refund_purchase`, `advance_demo`, and `run_jobs`.
+
+HTTP failures and invalid successful responses raise `AxletApiError` with `status` and `body`. Invalid keys raise `ValueError`. Network errors use the standard library's exceptions. Socket operations use a 75-second timeout, configurable with `timeout=`. Requests are synchronous, redirects are rejected, and no automatic retries are performed. Payment behavior depends on the API server configuration; installing this client does not enable production payments.
+
+## License
+
+All rights reserved. This release does not grant an open-source license.

axlet-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling>=1.26,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "axlet"
+version = "0.1.0"
+description = "Python client for the Axlet subscription and credits API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+keywords = ["axlet", "sdk", "subscriptions", "credits"]
+classifiers = ["Programming Language :: Python :: 3", "Operating System :: OS Independent"]
+
+[project.urls]
+Homepage = "https://axlet.app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/axlet"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/axlet", "pyproject.toml", "README.md", "LICENSE"]

axlet-0.1.0/src/axlet/__init__.py

@@ -0,0 +1,136 @@
+"""Server-side client for the Axlet API."""
+
+import json
+import re
+from urllib.error import HTTPError
+from urllib.parse import quote, urlencode, urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+__all__ = ["AxletClient", "AxletApiError"]
+
+
+class AxletApiError(Exception):
+    def __init__(self, status: int, message: str, body: object):
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        # 운영자 키가 리다이렉트 대상 서버로 전달되지 않게 합니다.
+        return None
+
+
+def _key(value: str) -> str:
+    if not isinstance(value, str) or not re.fullmatch(r"[a-zA-Z0-9_-]{8,100}", value):
+        raise ValueError("Keys must contain 8-100 ASCII letters, digits, underscores or hyphens.")
+    return value
+
+
+def _customer_path(customer_id: str, action: str) -> str:
+    return f"/api/customers/{quote(customer_id, safe='')}/{action}"
+
+
+class AxletClient:
+    def __init__(self, api_key: str, base_url: str = "http://127.0.0.1:4310", *, timeout: float = 75):
+        if not isinstance(api_key, str) or not api_key or "\r" in api_key or "\n" in api_key:
+            raise ValueError("A valid api_key is required.")
+        parsed = urlsplit(base_url)
+        if parsed.scheme not in ("http", "https") or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment:
+            raise ValueError("base_url must be an HTTP(S) URL without credentials, query or fragment.")
+        if timeout <= 0:
+            raise ValueError("timeout must be positive.")
+        self.base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self.timeout = timeout
+        self._opener = build_opener(_NoRedirect())
+
+    def _request(self, path: str, body: dict | None = None, idempotency_key: str | None = None) -> dict:
+        headers = {"Authorization": f"Bearer {self._api_key}", "Accept": "application/json"}
+        data = None
+        if body is not None:
+            headers["Idempotency-Key"] = _key(idempotency_key)
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+        request = Request(self.base_url + path, data=data, headers=headers)
+        try:
+            response = self._opener.open(request, timeout=self.timeout)
+        except HTTPError as error:
+            response = error
+        with response:
+            status = response.code
+            text = response.read().decode("utf-8", errors="replace")
+        try:
+            result = json.loads(text)
+        except ValueError:
+            result = text
+        if not 200 <= status < 300:
+            message = result.get("error") if isinstance(result, dict) else result
+            if not isinstance(message, str) or not message:
+                message = f"Axlet API request failed ({status})."
+            raise AxletApiError(status, message, result)
+        if not isinstance(result, dict):
+            raise AxletApiError(status, "Axlet API did not return a JSON object.", result)
+        return result
+
+    def get_plans(self) -> dict:
+        return self._request("/api/plans")
+
+    def set_plan(self, plan: dict, idempotency_key: str) -> dict:
+        return self._request("/api/plans", plan, idempotency_key)
+
+    def create_customer(self, customer: dict, idempotency_key: str) -> dict:
+        return self._request("/api/customers", customer, idempotency_key)
+
+    def register_billing(self, customer_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "billing"), {}, idempotency_key)
+
+    def subscribe(self, customer_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "subscribe"), {}, idempotency_key)
+
+    def cancel(self, customer_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "cancel"), {}, idempotency_key)
+
+    def refund(self, customer_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "refund"), {}, idempotency_key)
+
+    def retry(self, customer_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "retry"), {}, idempotency_key)
+
+    def get_entitlement(self, customer_id: str) -> dict:
+        return self._request(_customer_path(customer_id, "entitlement"))
+
+    def get_credits(self, customer_id: str) -> dict:
+        return self._request(_customer_path(customer_id, "credits"))
+
+    def get_access(self, customer_id: str, feature: str) -> dict:
+        return self._request(_customer_path(customer_id, "access") + "?" + urlencode({"feature": feature}))
+
+    def consume_usage(self, customer_id: str, usage: dict, idempotency_key: str) -> dict:
+        _key(usage.get("operationId"))
+        return self._request(_customer_path(customer_id, "usage"), usage, idempotency_key)
+
+    def cancel_usage(self, customer_id: str, operation_id: str, idempotency_key: str) -> dict:
+        return self._request(_customer_path(customer_id, "usage/cancel"), {"operationId": _key(operation_id)}, idempotency_key)
+
+    def create_purchase(self, purchase: dict, idempotency_key: str) -> dict:
+        return self._request("/api/purchases", purchase, idempotency_key)
+
+    def get_purchase(self, purchase_id: str) -> dict:
+        return self._request(f"/api/purchases/{quote(purchase_id, safe='')}")
+
+    def confirm_purchase(self, purchase_id: str, confirmation: dict, idempotency_key: str) -> dict:
+        return self._request(f"/api/purchases/{quote(purchase_id, safe='')}/confirm", confirmation, idempotency_key)
+
+    def sync_purchase(self, purchase_id: str, idempotency_key: str) -> dict:
+        return self._request(f"/api/purchases/{quote(purchase_id, safe='')}/sync", {}, idempotency_key)
+
+    def refund_purchase(self, purchase_id: str, idempotency_key: str) -> dict:
+        return self._request(f"/api/purchases/{quote(purchase_id, safe='')}/refund", {}, idempotency_key)
+
+    def advance_demo(self, days: int, idempotency_key: str) -> dict:
+        return self._request("/api/demo/advance", {"days": days}, idempotency_key)
+
+    def run_jobs(self, idempotency_key: str) -> dict:
+        return self._request("/api/jobs/run", {}, idempotency_key)