delula-sdk 0.1.0__tar.gz

delula_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: delula-sdk
+Version: 0.1.0
+Summary: Delula Public API SDK (beta)
+Author: Delula
+License: Proprietary
+Project-URL: Homepage, https://delu.la
+Project-URL: Repository, https://github.com/tcotten-scrypted/MagicVidCreator
+Project-URL: Issues, https://github.com/tcotten-scrypted/MagicVidCreator/issues
+Keywords: delula,api,generative-ai,video,image
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# delula-sdk
+
+Python client for the [Delula Public API](https://delu.la) (beta).
+
+## Install
+
+```bash
+pip install delula-sdk
+```
+
+Requires Python **3.10+**. No third-party dependencies (stdlib only).
+
+## Quick start
+
+Create an API key in Delula → **Account → API**, then:
+
+```python
+import uuid
+from delula_sdk import DelulaClient
+
+client = DelulaClient(api_key="dlu_...")
+
+credits = client.get_credits()
+recipes = client.list_recipes()["recipes"]
+preflight = client.preflight_generation(recipes[0]["id"], form_data={})
+gen = client.create_generation(
+    recipes[0]["id"],
+    form_data={},
+    idempotency_key=str(uuid.uuid4()),
+)
+result = client.wait_for_generation(gen["generationId"])
+```
+
+Default base URL: `https://delu.la/public/api`. Pass `base_url=` for local dev.
+
+## Beta
+
+Breaking changes may ship in `0.x` without a `/v1` path bump. Pin your version in production.

delula_sdk-0.1.0/README.md

@@ -0,0 +1,38 @@
+# delula-sdk
+
+Python client for the [Delula Public API](https://delu.la) (beta).
+
+## Install
+
+```bash
+pip install delula-sdk
+```
+
+Requires Python **3.10+**. No third-party dependencies (stdlib only).
+
+## Quick start
+
+Create an API key in Delula → **Account → API**, then:
+
+```python
+import uuid
+from delula_sdk import DelulaClient
+
+client = DelulaClient(api_key="dlu_...")
+
+credits = client.get_credits()
+recipes = client.list_recipes()["recipes"]
+preflight = client.preflight_generation(recipes[0]["id"], form_data={})
+gen = client.create_generation(
+    recipes[0]["id"],
+    form_data={},
+    idempotency_key=str(uuid.uuid4()),
+)
+result = client.wait_for_generation(gen["generationId"])
+```
+
+Default base URL: `https://delu.la/public/api`. Pass `base_url=` for local dev.
+
+## Beta
+
+Breaking changes may ship in `0.x` without a `/v1` path bump. Pin your version in production.

delula_sdk-0.1.0/delula_sdk/__init__.py

@@ -0,0 +1,6 @@
+"""Delula Public API SDK (beta)."""
+
+from delula_sdk.client import DelulaClient
+from delula_sdk.errors import DelulaApiError
+
+__all__ = ["DelulaClient", "DelulaApiError"]

delula_sdk-0.1.0/delula_sdk/client.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from typing import Any
+from urllib import error, request
+
+from delula_sdk.errors import DelulaApiError
+
+DEFAULT_BASE_URL = "https://delu.la/public/api"
+
+
+class DelulaClient:
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> Any:
+        url = f"{self.base_url}{path}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+        }
+        data: bytes | None = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+        if extra_headers:
+            headers.update(extra_headers)
+        req = request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with request.urlopen(req, timeout=120) as res:
+                payload = res.read().decode("utf-8")
+                return json.loads(payload) if payload else {}
+        except error.HTTPError as exc:
+            raw = exc.read().decode("utf-8")
+            try:
+                parsed = json.loads(raw)
+            except json.JSONDecodeError:
+                parsed = {}
+            raise DelulaApiError(
+                exc.code,
+                parsed.get("code", "internal_error"),
+                parsed.get("message", exc.reason),
+                parsed.get("details"),
+            ) from exc
+
+    def get_account(self) -> dict[str, Any]:
+        return self._request("GET", "/account")
+
+    def get_credits(self) -> dict[str, Any]:
+        return self._request("GET", "/account/credits")
+
+    def list_recipes(self, lang: str = "en") -> dict[str, Any]:
+        return self._request("GET", f"/recipes?lang={lang}")
+
+    def get_recipe(self, recipe_id: int, lang: str = "en") -> dict[str, Any]:
+        return self._request("GET", f"/recipes/{recipe_id}?lang={lang}")
+
+    def preflight_generation(
+        self, recipe_id: int, form_data: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            "/generations/preflight",
+            {"recipeId": recipe_id, "formData": form_data or {}},
+        )
+
+    def create_generation(
+        self,
+        recipe_id: int,
+        form_data: dict[str, Any] | None = None,
+        parameters: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        key = idempotency_key or str(uuid.uuid4())
+        return self._request(
+            "POST",
+            "/generations",
+            {
+                "recipeId": recipe_id,
+                "formData": form_data or {},
+                "parameters": parameters or {},
+            },
+            extra_headers={"Idempotency-Key": key},
+        )
+
+    def get_generation(self, generation_id: int) -> dict[str, Any]:
+        return self._request("GET", f"/generations/{generation_id}")
+
+    def list_generations(
+        self,
+        page: int = 1,
+        limit: int = 20,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        query = f"page={page}&limit={limit}"
+        if status:
+            query += f"&status={status}"
+        return self._request("GET", f"/generations?{query}")
+
+    def wait_for_generation(
+        self,
+        generation_id: int,
+        interval_s: float = 3.0,
+        timeout_s: float = 600.0,
+    ) -> dict[str, Any]:
+        started = time.time()
+        while True:
+            gen = self.get_generation(generation_id)
+            if gen.get("status") in ("completed", "failed"):
+                return gen
+            if time.time() - started > timeout_s:
+                raise DelulaApiError(408, "internal_error", f"Timed out waiting for generation {generation_id}")
+            time.sleep(interval_s)

delula_sdk-0.1.0/delula_sdk/errors.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class DelulaApiError(Exception):
+    def __init__(
+        self,
+        status: int,
+        code: str,
+        message: str,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.details = details or {}

delula_sdk-0.1.0/delula_sdk.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: delula-sdk
+Version: 0.1.0
+Summary: Delula Public API SDK (beta)
+Author: Delula
+License: Proprietary
+Project-URL: Homepage, https://delu.la
+Project-URL: Repository, https://github.com/tcotten-scrypted/MagicVidCreator
+Project-URL: Issues, https://github.com/tcotten-scrypted/MagicVidCreator/issues
+Keywords: delula,api,generative-ai,video,image
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# delula-sdk
+
+Python client for the [Delula Public API](https://delu.la) (beta).
+
+## Install
+
+```bash
+pip install delula-sdk
+```
+
+Requires Python **3.10+**. No third-party dependencies (stdlib only).
+
+## Quick start
+
+Create an API key in Delula → **Account → API**, then:
+
+```python
+import uuid
+from delula_sdk import DelulaClient
+
+client = DelulaClient(api_key="dlu_...")
+
+credits = client.get_credits()
+recipes = client.list_recipes()["recipes"]
+preflight = client.preflight_generation(recipes[0]["id"], form_data={})
+gen = client.create_generation(
+    recipes[0]["id"],
+    form_data={},
+    idempotency_key=str(uuid.uuid4()),
+)
+result = client.wait_for_generation(gen["generationId"])
+```
+
+Default base URL: `https://delu.la/public/api`. Pass `base_url=` for local dev.
+
+## Beta
+
+Breaking changes may ship in `0.x` without a `/v1` path bump. Pin your version in production.

delula_sdk-0.1.0/delula_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+delula_sdk/__init__.py
+delula_sdk/client.py
+delula_sdk/errors.py
+delula_sdk.egg-info/PKG-INFO
+delula_sdk.egg-info/SOURCES.txt
+delula_sdk.egg-info/dependency_links.txt
+delula_sdk.egg-info/top_level.txt
+tests/test_integration.py

delula_sdk-0.1.0/delula_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

delula_sdk-0.1.0/delula_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+delula_sdk

delula_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "delula-sdk"
+version = "0.1.0"
+description = "Delula Public API SDK (beta)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Proprietary" }
+authors = [{ name = "Delula" }]
+keywords = ["delula", "api", "generative-ai", "video", "image"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://delu.la"
+Repository = "https://github.com/tcotten-scrypted/MagicVidCreator"
+Issues = "https://github.com/tcotten-scrypted/MagicVidCreator/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["delula_sdk*"]

delula_sdk-0.1.0/setup.cfg

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

delula_sdk-0.1.0/tests/test_integration.py

@@ -0,0 +1,120 @@
+"""Live Public API integration tests for delula-sdk."""
+
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+import uuid
+from pathlib import Path
+
+# repo root on path for shared helpers + package under test
+ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(ROOT / "sdk" / "python"))
+sys.path.insert(0, str(ROOT / "sdk" / "tests"))
+
+from delula_sdk import DelulaClient  # noqa: E402
+from delula_sdk.errors import DelulaApiError  # noqa: E402
+from recipe_fixtures import build_minimal_form_data, pick_cheapest_recipe  # noqa: E402
+
+
+def _load_config() -> tuple[str, str, bool, int | None]:
+    api_key = (os.environ.get("DELULA_API_KEY") or "").strip()
+    if not api_key:
+        raise unittest.SkipTest("DELULA_API_KEY is required for SDK integration tests")
+    base_url = (os.environ.get("DELULA_API_BASE_URL") or "https://delu.la/public/api").rstrip("/")
+    run_write = os.environ.get("DELULA_SDK_RUN_WRITE_TESTS") == "1"
+    recipe_raw = (os.environ.get("DELULA_SDK_TEST_RECIPE_ID") or "").strip()
+    recipe_id = int(recipe_raw) if recipe_raw.isdigit() else None
+    return api_key, base_url, run_write, recipe_id
+
+
+class DelulaSdkIntegrationTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        api_key, base_url, run_write, recipe_id = _load_config()
+        cls.api_key = api_key
+        cls.base_url = base_url
+        cls.run_write = run_write
+        cls.recipe_id = recipe_id
+        cls.client = DelulaClient(api_key, base_url=base_url)
+
+    def test_invalid_api_key(self) -> None:
+        bad = DelulaClient("dlu_invalid_key_for_test", base_url=self.base_url)
+        with self.assertRaises(DelulaApiError) as ctx:
+            bad.get_account()
+        self.assertEqual(ctx.exception.status, 401)
+        self.assertEqual(ctx.exception.code, "invalid_api_key")
+
+    def test_get_account(self) -> None:
+        account = self.client.get_account()
+        self.assertIsInstance(account.get("userId"), str)
+        self.assertTrue(account["userId"])
+
+    def test_get_credits(self) -> None:
+        credits = self.client.get_credits()
+        for key in ("totalCredits", "premiumCredits", "earnedCredits", "apiEligibleCredits"):
+            self.assertIn(key, credits)
+            self.assertIsInstance(credits[key], int)
+        self.assertEqual(credits["apiEligibleCredits"], credits["premiumCredits"])
+        breakdown = credits.get("breakdown") or {}
+        self.assertIn("premium", breakdown)
+        self.assertIn("earned", breakdown)
+
+    def test_list_recipes(self) -> None:
+        recipes = self.client.list_recipes().get("recipes") or []
+        self.assertGreater(len(recipes), 0)
+        for recipe in recipes[:5]:
+            self.assertIsInstance(recipe.get("id"), int)
+            self.assertIsInstance(recipe.get("name"), str)
+            self.assertIsInstance(recipe.get("creditCost"), int)
+
+    def test_get_recipe(self) -> None:
+        recipes = self.client.list_recipes().get("recipes") or []
+        pick = pick_cheapest_recipe(recipes, self.recipe_id)
+        detail = self.client.get_recipe(pick["id"])
+        self.assertEqual(detail["id"], pick["id"])
+        self.assertIsInstance(detail.get("name"), str)
+        self.assertEqual(detail["creditCost"], pick["creditCost"])
+
+    def test_list_generations(self) -> None:
+        result = self.client.list_generations(page=1, limit=5)
+        self.assertIn("generations", result)
+        self.assertIn("pagination", result)
+        self.assertIsInstance(result["generations"], list)
+        self.assertIsInstance(result["pagination"].get("page"), int)
+
+    def test_preflight_generation(self) -> None:
+        recipes = self.client.list_recipes().get("recipes") or []
+        pick = pick_cheapest_recipe(recipes, self.recipe_id)
+        detail = self.client.get_recipe(pick["id"])
+        form_data = build_minimal_form_data(detail)
+        result = self.client.preflight_generation(pick["id"], form_data)
+        self.assertTrue(result.get("passed"))
+
+    def test_recipe_not_found(self) -> None:
+        with self.assertRaises(DelulaApiError) as ctx:
+            self.client.get_recipe(999999999)
+        self.assertEqual(ctx.exception.status, 404)
+        self.assertEqual(ctx.exception.code, "recipe_not_found")
+
+    @unittest.skipUnless(os.environ.get("DELULA_SDK_RUN_WRITE_TESTS") == "1", "write tests disabled")
+    def test_create_generation_idempotent(self) -> None:
+        credits = self.client.get_credits()
+        recipes = self.client.list_recipes().get("recipes") or []
+        pick = pick_cheapest_recipe(recipes, self.recipe_id)
+        detail = self.client.get_recipe(pick["id"])
+        cost = detail["creditCost"]
+        if credits.get("premiumCredits", 0) < cost:
+            self.skipTest(f"Need {cost} premium credits; have {credits.get('premiumCredits', 0)}")
+
+        form_data = build_minimal_form_data(detail)
+        key = str(uuid.uuid4())
+        first = self.client.create_generation(pick["id"], form_data=form_data, idempotency_key=key)
+        self.assertIsInstance(first.get("generationId"), int)
+        second = self.client.create_generation(pick["id"], form_data=form_data, idempotency_key=key)
+        self.assertEqual(first.get("generationId"), second.get("generationId"))
+
+
+if __name__ == "__main__":
+    unittest.main()