manyagi-sdk 0.1.0__py3-none-any.whl

manyagi_sdk/__init__.py

@@ -0,0 +1,18 @@
+from .client import (
+    EXTERNAL_MCP_RESOURCE,
+    EXTERNAL_SCOPES,
+    ManyagiClient,
+    ManyagiError,
+    assert_external_client_credential,
+    external_credential_kind,
+)
+
+__all__ = [
+    "EXTERNAL_MCP_RESOURCE",
+    "EXTERNAL_SCOPES",
+    "ManyagiClient",
+    "ManyagiError",
+    "assert_external_client_credential",
+    "external_credential_kind",
+]
+__version__ = "0.1.0"

manyagi_sdk/client.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Callable
+from urllib.error import HTTPError
+from urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
+
+
+class ManyagiError(Exception):
+    def __init__(self, status: int, code: str, message: str, request_id: str | None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+
+
+@dataclass
+class ManyagiClient:
+    """Product-session client. Passport tokens are not accepted. POST is not retried."""
+
+    base_url: str
+    access_token: str | None = None
+    timeout: float = 10.0
+    max_get_retries: int = 2
+    opener: Callable[[Request, float], Any] | None = None
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+
+    def platform(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/platform")
+
+    def open_api(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/openapi.json")
+
+    def search_worlds(self, query: str = "", limit: int = 20, offset: int = 0) -> dict[str, Any]:
+        params = urlencode({k: v for k, v in {"q": query, "limit": limit, "offset": offset}.items() if v})
+        return self._request("GET", f"/api/v1/discovery/worlds?{params}" if params else "/api/v1/discovery/worlds")
+
+    def world(self, ref: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/discovery/worlds/{quote(ref)}")
+
+    def rights(self, world: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/discovery/rights?world={quote(world)}")
+
+    def list_my_worlds(self, limit: int = 20) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/me/worlds?limit={limit}")
+
+    def read_world(self, ref: str) -> dict[str, Any]:
+        return self._request("GET", f"/api/v1/me/worlds/{quote(ref)}")
+
+    def credits(self) -> dict[str, Any]:
+        return self._request("GET", "/api/v1/me/credits")
+
+    def prepare_brief(self, body: dict[str, Any], idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/briefs", body, idempotency_key)
+
+    def prepare_song(self, body: dict[str, Any], idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/briefs/song", body, idempotency_key)
+
+    def prepare_licensing_inquiry(self, body: dict[str, Any], idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/licensing/inquiries/prepare", body, idempotency_key)
+
+    def assistant(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/api/v1/assistant", body)
+
+    def _request(self, method: str, path: str, body: dict[str, Any] | None = None, idempotency_key: str | None = None) -> dict[str, Any]:
+        headers = {"Accept": "application/json"}
+        data = None
+        if self.access_token and external_credential_kind(self.access_token) == "external":
+            raise ManyagiError(0, "external_credential_rejected", "An external grant cannot be sent to the product API.", None)
+        if self.access_token:
+            headers["Authorization"] = f"Bearer {self.access_token}"
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode()
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        attempts = self.max_get_retries + 1 if method == "GET" else 1
+        last_error: HTTPError | None = None
+        for attempt in range(attempts):
+            request = Request(f"{self.base_url}{path}", data=data, headers=headers, method=method)
+            try:
+                if self.opener:
+                    response = self.opener(request, self.timeout)
+                else:
+                    response = urlopen(request, timeout=self.timeout)
+            except HTTPError as error:
+                last_error = error
+                if method == "GET" and error.code in (429, 503) and attempt + 1 < attempts:
+                    continue
+                payload = json.loads(error.read().decode() or "{}")
+                detail = payload.get("error", {})
+                raise ManyagiError(error.code, detail.get("code", "request_failed"), detail.get("message", error.reason), error.headers.get("x-request-id")) from None
+            raw = response.read().decode()
+            parsed = json.loads(raw or "{}")
+            status = getattr(response, "status", 200)
+            if status >= 400:
+                detail = parsed.get("error", {})
+                raise ManyagiError(status, detail.get("code", "request_failed"), detail.get("message", "request failed"), None)
+            return parsed
+        if last_error is not None:
+            raise last_error
+        raise ManyagiError(0, "request_failed", "request failed", None)
+
+
+EXTERNAL_MCP_RESOURCE = "https://manyagi.com/mcp"
+EXTERNAL_SCOPES = (
+    "worlds:read_owned",
+    "credits:read",
+    "discovery:read_public",
+    "rights:read_public",
+    "briefs:prepare",
+    "licensing:prepare",
+)
+
+
+def external_credential_kind(token: str) -> str:
+    if token.startswith("mga_") and "." not in token:
+        return "external"
+    if token.count(".") == 2:
+        return "product_jwt"
+    return "rejected"
+
+
+def assert_external_client_credential(token: str) -> None:
+    kind = external_credential_kind(token)
+    if kind == "external":
+        return
+    message = (
+        "A product session cannot be used as an external client credential."
+        if kind == "product_jwt"
+        else "The external credential was rejected."
+    )
+    raise ManyagiError(0, "external_credential_required", message, None)

manyagi_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: manyagi-sdk
+Version: 0.1.0
+Summary: Manyagi platform client for the read and preparation API. Not yet published to PyPI.
+Author: Manyagi
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# manyagi-sdk
+
+Python client for the Manyagi platform read and preparation API.
+
+Version `0.1.0`. Publication uses GitHub Actions workflow `publish-pypi-sdk.yml` (environment `pypi-sdk`) with PyPI Trusted Publishing (OIDC). Until published, install from a checkout for tests:
+
+```bash
+PYTHONPATH=packages/manyagi-sdk-python/src python -c "from manyagi_sdk import ManyagiClient; print(ManyagiClient('https://manyagi.com').platform())"
+```
+
+Pass a Manyagi product-session access token. Do not pass a Passport token or a service-role key. `POST` requests are not retried.

manyagi_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+manyagi_sdk/__init__.py,sha256=wfP4AT3r0uFrA59ygedy_1rIdkwZ8-BEa0WTBfJmZCk,381
+manyagi_sdk/client.py,sha256=kkNT8XTlJpzre48HBhCcaSvVHx0dwUzXGAjwyyo4fs8,5764
+manyagi_sdk-0.1.0.dist-info/METADATA,sha256=2tvEOJy-M5SfxMj_eVNYF_RX_ZIpzFXw9gW2zffzHRQ,842
+manyagi_sdk-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+manyagi_sdk-0.1.0.dist-info/top_level.txt,sha256=PdJU09EHuFMxt94inBK9TIjiVvnQtNI2HxQzeL7BY9Q,12
+manyagi_sdk-0.1.0.dist-info/RECORD,,

manyagi_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

manyagi_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+manyagi_sdk