manyagi-sdk 0.1.0__tar.gz

manyagi_sdk-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,11 @@
+# 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/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "manyagi-sdk"
+version = "0.1.0"
+description = "Manyagi platform client for the read and preparation API. Not yet published to PyPI."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "LicenseRef-Proprietary"
+authors = [{ name = "Manyagi" }]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"

manyagi_sdk-0.1.0/setup.cfg

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

manyagi_sdk-0.1.0/src/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-0.1.0/src/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/src/manyagi_sdk.egg-info/PKG-INFO

@@ -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/src/manyagi_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/manyagi_sdk/__init__.py
+src/manyagi_sdk/client.py
+src/manyagi_sdk.egg-info/PKG-INFO
+src/manyagi_sdk.egg-info/SOURCES.txt
+src/manyagi_sdk.egg-info/dependency_links.txt
+src/manyagi_sdk.egg-info/top_level.txt
+tests/test_client.py

manyagi_sdk-0.1.0/src/manyagi_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

manyagi_sdk-0.1.0/src/manyagi_sdk.egg-info/top_level.txt

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

manyagi_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,53 @@
+import json
+import unittest
+from urllib.request import Request
+
+from manyagi_sdk import ManyagiClient, ManyagiError, assert_external_client_credential
+
+
+class FakeResponse:
+    def __init__(self, status, payload, headers=None):
+        self.status = status
+        self._payload = payload
+        self.headers = headers or {}
+
+    def read(self):
+        return json.dumps(self._payload).encode()
+
+
+class ClientTests(unittest.TestCase):
+    def test_get_sends_bearer_and_does_not_post_twice(self):
+        seen = []
+
+        def opener(request: Request, timeout: float):
+            seen.append((request.get_method(), request.full_url, request.get_header("Authorization"), timeout))
+            if request.get_method() == "POST":
+                return FakeResponse(401, {"error": {"code": "unauthorized", "message": "Sign in"}})
+            return FakeResponse(200, {"api_version": "2026-11-05", "writes_enabled": False})
+
+        client = ManyagiClient("https://manyagi.com/", access_token="product-token", opener=opener)
+        body = client.platform()
+        self.assertFalse(body["writes_enabled"])
+        self.assertEqual(seen[0][0], "GET")
+        self.assertEqual(seen[0][1], "https://manyagi.com/api/v1/platform")
+        self.assertEqual(seen[0][2], "Bearer product-token")
+        with self.assertRaises(ManyagiError) as raised:
+            client.prepare_brief({"idea": "x", "source_medium": "original_idea"})
+        self.assertEqual(raised.exception.code, "unauthorized")
+        self.assertEqual(len(seen), 2)
+
+    def test_product_client_refuses_external_grant(self):
+        client = ManyagiClient("https://manyagi.com/", access_token="mga_abc", opener=lambda request, timeout: None)
+        with self.assertRaises(ManyagiError) as raised:
+            client.platform()
+        self.assertEqual(raised.exception.code, "external_credential_rejected")
+
+    def test_external_credential_rejects_product_jwt(self):
+        assert_external_client_credential("mga_abc")
+        with self.assertRaises(ManyagiError) as raised:
+            assert_external_client_credential("aaa.bbb.ccc")
+        self.assertEqual(raised.exception.code, "external_credential_required")
+
+
+if __name__ == "__main__":
+    unittest.main()