indream-client 0.1.1__py3-none-any.whl

indream/__init__.py

@@ -0,0 +1,15 @@
+from indream.async_client import AsyncIndreamClient
+from indream.client import IndreamClient
+from indream.errors import APIError, AuthError, RateLimitError, ValidationError
+from indream.webhooks import verify_export_webhook_request, verify_export_webhook_signature
+
+__all__ = [
+    "IndreamClient",
+    "AsyncIndreamClient",
+    "APIError",
+    "AuthError",
+    "RateLimitError",
+    "ValidationError",
+    "verify_export_webhook_signature",
+    "verify_export_webhook_request",
+]

indream/async_client.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import asyncio
+import random
+from typing import Any
+
+import httpx
+
+from indream.errors import APIError, Problem, create_api_error
+from indream.resources.editor import AsyncEditorResource
+
+TERMINAL_STATUSES = {"COMPLETED", "FAILED", "CANCELED"}
+
+
+class AsyncExportsResource:
+    def __init__(self, request: Any, poll_interval: float) -> None:
+        self._request = request
+        self._poll_interval = poll_interval
+
+    async def create(
+        self,
+        payload: dict[str, Any],
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        data = await self._request(
+            "POST",
+            "/v1/exports",
+            json=payload,
+            idempotency_key=idempotency_key,
+        )
+        if not isinstance(data, dict):
+            raise TypeError("Unexpected response payload")
+        return data
+
+    async def get(self, task_id: str) -> dict[str, Any]:
+        data = await self._request("GET", f"/v1/exports/{task_id}")
+        if not isinstance(data, dict):
+            raise TypeError("Unexpected response payload")
+        return data
+
+    async def list(
+        self,
+        page_size: int | None = None,
+        page_cursor: str | None = None,
+        created_by_api_key_id: str | None = None,
+    ) -> dict[str, Any]:
+        query: list[str] = []
+        if page_size is not None:
+            query.append(f"pageSize={page_size}")
+        if page_cursor is not None:
+            query.append(f"pageCursor={page_cursor}")
+        if created_by_api_key_id is not None:
+            query.append(f"createdByApiKeyId={created_by_api_key_id}")
+
+        suffix = f"?{'&'.join(query)}" if query else ""
+        envelope = await self._request("GET", f"/v1/exports{suffix}", unwrap_data=False)
+
+        # Keep the response envelope so pagination cursor metadata stays available.
+        if not isinstance(envelope, dict):
+            raise TypeError("Unexpected response payload")
+
+        raw_items = envelope.get("data")
+        if not isinstance(raw_items, list):
+            raise TypeError("Unexpected response payload")
+
+        meta = envelope.get("meta")
+        if not isinstance(meta, dict):
+            raise TypeError("Unexpected response payload")
+
+        next_page_cursor = meta.get("nextPageCursor")
+        if next_page_cursor is not None and not isinstance(next_page_cursor, str):
+            raise TypeError("Unexpected response payload")
+
+        items = [item for item in raw_items if isinstance(item, dict)]
+        return {"items": items, "nextPageCursor": next_page_cursor}
+
+    async def wait(
+        self,
+        task_id: str,
+        timeout: float = 600,
+        poll_interval: float | None = None,
+    ) -> dict[str, Any]:
+        interval = poll_interval if poll_interval is not None else self._poll_interval
+        loop = asyncio.get_running_loop()
+        started = loop.time()
+
+        while True:
+            if loop.time() - started > timeout:
+                raise TimeoutError(f"wait timeout after {timeout} seconds")
+
+            task = await self.get(task_id)
+            status = task.get("status")
+            if status in TERMINAL_STATUSES:
+                if status in {"FAILED", "CANCELED"}:
+                    raise APIError(
+                        Problem(
+                            type="TASK_TERMINAL_FAILURE",
+                            title="Task failed",
+                            status=422,
+                            detail=task.get("error") or f"Task ended with status {status}",
+                            error_code="TASK_TERMINAL_FAILURE",
+                        )
+                    )
+                return task
+
+            await asyncio.sleep(interval)
+
+
+class AsyncIndreamClient:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://api.indream.ai",
+        timeout: float = 60,
+        max_retries: int = 2,
+        poll_interval: float = 2,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._poll_interval = poll_interval
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            transport=transport,
+        )
+
+        self.exports = AsyncExportsResource(self._request, self._poll_interval)
+        self.editor = AsyncEditorResource(self._request)
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+        skip_retry: bool = False,
+        unwrap_data: bool = True,
+    ) -> Any:
+        attempt = 0
+
+        while True:
+            try:
+                headers = {
+                    "x-api-key": self._api_key,
+                    "Accept": "application/json",
+                }
+                if idempotency_key:
+                    headers["Idempotency-Key"] = idempotency_key
+
+                response = await self._client.request(method, path, json=json, headers=headers)
+                payload = response.json() if response.content else {}
+
+                if response.status_code >= 400:
+                    raise create_api_error(response.status_code, payload)
+
+                if not isinstance(payload, dict) or "data" not in payload:
+                    raise create_api_error(response.status_code, payload)
+
+                if "meta" not in payload:
+                    raise create_api_error(response.status_code, payload)
+
+                if not unwrap_data:
+                    return payload
+
+                data = payload["data"]
+                if not isinstance(data, dict):
+                    raise create_api_error(response.status_code, payload)
+
+                return data
+            except APIError as error:
+                if skip_retry:
+                    raise
+
+                if not self._should_retry(error.status) or attempt >= self._max_retries:
+                    raise
+
+                await self._sleep_with_backoff(attempt)
+                attempt += 1
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.WriteTimeout):
+                if skip_retry or attempt >= self._max_retries:
+                    raise
+                await self._sleep_with_backoff(attempt)
+                attempt += 1
+
+    @staticmethod
+    def _should_retry(status: int) -> bool:
+        return status == 429 or status >= 500
+
+    @staticmethod
+    async def _sleep_with_backoff(attempt: int) -> None:
+        base = min(3.0, 0.3 * (2**attempt))
+        jitter = random.random() * 0.1
+        await asyncio.sleep(base + jitter)

indream/client.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import random
+import time
+from typing import Any
+
+import httpx
+
+from indream.errors import APIError, create_api_error
+from indream.resources.editor import EditorResource
+from indream.resources.exports import ExportsResource
+
+
+class IndreamClient:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://api.indream.ai",
+        timeout: float = 60,
+        max_retries: int = 2,
+        poll_interval: float = 2,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._poll_interval = poll_interval
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            transport=transport,
+        )
+
+        self.exports = ExportsResource(self._request, self._poll_interval)
+        self.editor = EditorResource(self._request)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> IndreamClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+        skip_retry: bool = False,
+        unwrap_data: bool = True,
+    ) -> Any:
+        attempt = 0
+
+        while True:
+            try:
+                headers = {
+                    "x-api-key": self._api_key,
+                    "Accept": "application/json",
+                }
+                if idempotency_key:
+                    headers["Idempotency-Key"] = idempotency_key
+
+                response = self._client.request(method, path, json=json, headers=headers)
+                payload = response.json() if response.content else {}
+
+                if response.status_code >= 400:
+                    raise create_api_error(response.status_code, payload)
+
+                if not isinstance(payload, dict) or "data" not in payload:
+                    raise create_api_error(response.status_code, payload)
+
+                if "meta" not in payload:
+                    raise create_api_error(response.status_code, payload)
+
+                if not unwrap_data:
+                    return payload
+
+                data = payload["data"]
+                if not isinstance(data, dict):
+                    raise create_api_error(response.status_code, payload)
+
+                return data
+            except APIError as error:
+                if skip_retry:
+                    raise
+
+                if not self._should_retry(error.status) or attempt >= self._max_retries:
+                    raise
+
+                self._sleep_with_backoff(attempt)
+                attempt += 1
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.WriteTimeout):
+                if skip_retry or attempt >= self._max_retries:
+                    raise
+                self._sleep_with_backoff(attempt)
+                attempt += 1
+
+    @staticmethod
+    def _should_retry(status: int) -> bool:
+        return status == 429 or status >= 500
+
+    @staticmethod
+    def _sleep_with_backoff(attempt: int) -> None:
+        # Use exponential backoff with jitter to reduce retry bursts
+        # under shared throttling windows.
+        base = min(3.0, 0.3 * (2**attempt))
+        jitter = random.random() * 0.1
+        time.sleep(base + jitter)

indream/errors.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Problem:
+    type: str
+    title: str
+    status: int
+    detail: str
+    error_code: str | None = None
+
+
+class APIError(Exception):
+    def __init__(self, problem: Problem):
+        super().__init__(problem.detail)
+        self.problem = problem
+        self.status = problem.status
+        self.type = problem.type
+        self.error_code = problem.error_code
+
+
+class AuthError(APIError):
+    pass
+
+
+class ValidationError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    pass
+
+
+def parse_problem(status: int, payload: Any) -> Problem:
+    if isinstance(payload, dict):
+        maybe_type = payload.get("type")
+        maybe_title = payload.get("title")
+        if isinstance(maybe_type, str) and isinstance(maybe_title, str):
+            return Problem(
+                type=maybe_type,
+                title=maybe_title,
+                status=int(payload.get("status") or status),
+                detail=str(payload.get("detail") or maybe_title),
+                error_code=payload.get("errorCode"),
+            )
+
+    return Problem(
+        type="INTERNAL_ERROR",
+        title="Internal server error",
+        status=status,
+        detail="Unexpected API response",
+        error_code="SDK_UNEXPECTED_RESPONSE",
+    )
+
+
+def create_api_error(status: int, payload: Any) -> APIError:
+    problem = parse_problem(status, payload)
+
+    if status in (401, 403):
+        return AuthError(problem)
+    if status in (400, 422):
+        return ValidationError(problem)
+    if status == 429:
+        return RateLimitError(problem)
+
+    return APIError(problem)

indream/resources/__init__.py

@@ -0,0 +1 @@
+# resources package

indream/resources/editor.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from indream.types import EditorCapabilities, EditorValidationResult
+
+
+class EditorResource:
+    def __init__(self, request: Callable[..., dict[str, Any]]) -> None:
+        self._request = request
+
+    def capabilities(self) -> EditorCapabilities:
+        data = self._request("GET", "/v1/editor/capabilities")
+        return EditorCapabilities.model_validate(data)
+
+    def validate(self, editor_state: dict[str, Any]) -> EditorValidationResult:
+        data = self._request(
+            "POST",
+            "/v1/editor/validate",
+            json={"editorState": editor_state},
+            skip_retry=True,
+        )
+        return EditorValidationResult.model_validate(data)
+
+
+class AsyncEditorResource:
+    def __init__(self, request: Callable[..., Any]) -> None:
+        self._request = request
+
+    async def capabilities(self) -> EditorCapabilities:
+        data = await self._request("GET", "/v1/editor/capabilities")
+        return EditorCapabilities.model_validate(data)
+
+    async def validate(self, editor_state: dict[str, Any]) -> EditorValidationResult:
+        data = await self._request(
+            "POST",
+            "/v1/editor/validate",
+            json={"editorState": editor_state},
+            skip_retry=True,
+        )
+        return EditorValidationResult.model_validate(data)

indream/resources/exports.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import Any
+
+from indream.errors import APIError, Problem
+from indream.types import ExportCreateResponse, ExportTask, ExportTaskListResponse
+
+TERMINAL_STATUSES = {"COMPLETED", "FAILED", "CANCELED"}
+
+
+class ExportsResource:
+    def __init__(self, request: Callable[..., Any], poll_interval: float) -> None:
+        self._request = request
+        self._poll_interval = poll_interval
+
+    def create(
+        self,
+        payload: dict[str, Any],
+        idempotency_key: str | None = None,
+    ) -> ExportCreateResponse:
+        data = self._request(
+            "POST",
+            "/v1/exports",
+            json=payload,
+            idempotency_key=idempotency_key,
+        )
+        return ExportCreateResponse.model_validate(data)
+
+    def get(self, task_id: str) -> ExportTask:
+        data = self._request("GET", f"/v1/exports/{task_id}")
+        return ExportTask.model_validate(data)
+
+    def list(
+        self,
+        page_size: int | None = None,
+        page_cursor: str | None = None,
+        created_by_api_key_id: str | None = None,
+    ) -> ExportTaskListResponse:
+        query: list[str] = []
+        if page_size is not None:
+            query.append(f"pageSize={page_size}")
+        if page_cursor is not None:
+            query.append(f"pageCursor={page_cursor}")
+        if created_by_api_key_id is not None:
+            query.append(f"createdByApiKeyId={created_by_api_key_id}")
+
+        suffix = f"?{'&'.join(query)}" if query else ""
+        envelope = self._request("GET", f"/v1/exports{suffix}", unwrap_data=False)
+
+        # Keep envelope meta for pagination cursor handling.
+        if not isinstance(envelope, dict):
+            raise TypeError("Unexpected response payload")
+
+        raw_items = envelope.get("data")
+        if not isinstance(raw_items, list):
+            raise TypeError("Unexpected response payload")
+
+        meta = envelope.get("meta")
+        if not isinstance(meta, dict):
+            raise TypeError("Unexpected response payload")
+
+        next_page_cursor = meta.get("nextPageCursor")
+        if next_page_cursor is not None and not isinstance(next_page_cursor, str):
+            raise TypeError("Unexpected response payload")
+
+        items = [ExportTask.model_validate(item) for item in raw_items]
+        return ExportTaskListResponse(items=items, nextPageCursor=next_page_cursor)
+
+    def wait(
+        self,
+        task_id: str,
+        timeout: float = 600,
+        poll_interval: float | None = None,
+    ) -> ExportTask:
+        interval = poll_interval if poll_interval is not None else self._poll_interval
+        started = time.time()
+
+        # Polling follows the server task state machine and stops only on terminal states.
+        while True:
+            if time.time() - started > timeout:
+                raise TimeoutError(f"wait timeout after {timeout} seconds")
+
+            task = self.get(task_id)
+            if task.status in TERMINAL_STATUSES:
+                if task.status in {"FAILED", "CANCELED"}:
+                    raise APIError(
+                        Problem(
+                            type="TASK_TERMINAL_FAILURE",
+                            title="Task failed",
+                            status=422,
+                            detail=task.error or f"Task ended with status {task.status}",
+                            error_code="TASK_TERMINAL_FAILURE",
+                        )
+                    )
+                return task
+
+            time.sleep(interval)

indream/types.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+TaskStatus = Literal["PENDING", "PROCESSING", "COMPLETED", "FAILED", "PAUSED", "CANCELED"]
+WebhookEventType = Literal["EXPORT_STARTED", "EXPORT_COMPLETED", "EXPORT_FAILED"]
+
+
+class ExportCreateResponse(BaseModel):
+    task_id: str = Field(alias="taskId")
+    created_at: str = Field(alias="createdAt")
+    duration_seconds: float = Field(alias="durationSeconds")
+    billed_standard_seconds: int = Field(alias="billedStandardSeconds")
+    charged_credits: str = Field(alias="chargedCredits")
+
+
+class ExportTask(BaseModel):
+    task_id: str = Field(alias="taskId")
+    created_by_api_key_id: str | None = Field(alias="createdByApiKeyId")
+    client_task_id: str | None = Field(alias="clientTaskId")
+    status: TaskStatus
+    progress: float
+    error: str | None
+    output_url: str | None = Field(alias="outputUrl")
+    duration_seconds: float = Field(alias="durationSeconds")
+    billed_standard_seconds: int = Field(alias="billedStandardSeconds")
+    charged_credits: str = Field(alias="chargedCredits")
+    callback_url: str | None = Field(alias="callbackUrl")
+    created_at: str = Field(alias="createdAt")
+    completed_at: str | None = Field(alias="completedAt")
+
+
+class ExportTaskListResponse(BaseModel):
+    items: list[ExportTask]
+    next_page_cursor: str | None = Field(alias="nextPageCursor")
+
+
+class ExportWebhookEvent(BaseModel):
+    event_type: WebhookEventType = Field(alias="eventType")
+    occurred_at: str = Field(alias="occurredAt")
+    task: ExportTask
+
+
+class EditorCapabilities(BaseModel):
+    version: str
+    animations: list[str]
+    transitions: list[str]
+    transition_presets: list[dict[str, Any]] = Field(alias="transitionPresets")
+    effects: list[str]
+    effect_presets: list[dict[str, Any]] = Field(alias="effectPresets")
+    filters: list[str]
+    filter_presets: list[dict[str, Any]] = Field(alias="filterPresets")
+    shapes: list[str]
+    background_presets: dict[str, Any] = Field(alias="backgroundPresets")
+    illustrations: list[str]
+
+
+class EditorValidationError(BaseModel):
+    code: str
+    path: str
+    message: str
+
+
+class EditorValidationResult(BaseModel):
+    valid: bool
+    errors: list[EditorValidationError]

indream/webhooks.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import hmac
+import time
+from collections.abc import Mapping
+from hashlib import sha256
+
+INDREAM_WEBHOOK_TIMESTAMP_HEADER = "x-indream-timestamp"
+INDREAM_WEBHOOK_SIGNATURE_HEADER = "x-indream-signature"
+DEFAULT_WEBHOOK_MAX_SKEW_SECONDS = 300
+
+
+def _resolve_header_value(headers: Mapping[str, object], target_key: str) -> str | None:
+    lower_key = target_key.lower()
+    for key, value in headers.items():
+        if key.lower() != lower_key:
+            continue
+        if isinstance(value, list | tuple):
+            value = value[0] if value else None
+        if isinstance(value, bytes):
+            try:
+                value = value.decode("utf-8")
+            except UnicodeDecodeError:
+                return None
+        if not isinstance(value, str):
+            return None
+        normalized = value.strip()
+        return normalized or None
+    return None
+
+
+def verify_export_webhook_signature(
+    *,
+    webhook_secret: str,
+    timestamp: str,
+    raw_body: str,
+    signature: str,
+) -> bool:
+    if not webhook_secret or not timestamp or not signature:
+        return False
+
+    normalized_signature = signature.strip().lower()
+    if len(normalized_signature) != 64:
+        return False
+    if any(ch not in "0123456789abcdef" for ch in normalized_signature):
+        return False
+
+    payload = f"{timestamp}.{raw_body}".encode()
+    expected = hmac.new(webhook_secret.encode(), payload, sha256).hexdigest()
+    return hmac.compare_digest(expected, normalized_signature)
+
+
+def verify_export_webhook_request(
+    *,
+    webhook_secret: str,
+    raw_body: str,
+    headers: Mapping[str, object],
+    max_skew_seconds: int = DEFAULT_WEBHOOK_MAX_SKEW_SECONDS,
+    now_timestamp_seconds: int | None = None,
+) -> bool:
+    timestamp = _resolve_header_value(headers, INDREAM_WEBHOOK_TIMESTAMP_HEADER)
+    signature = _resolve_header_value(headers, INDREAM_WEBHOOK_SIGNATURE_HEADER)
+    if timestamp is None or signature is None:
+        return False
+
+    if not timestamp.isdigit():
+        return False
+    timestamp_seconds = int(timestamp)
+
+    if max_skew_seconds < 0:
+        return False
+    current_timestamp = int(time.time()) if now_timestamp_seconds is None else now_timestamp_seconds
+    if current_timestamp < 0:
+        return False
+
+    # Enforce a bounded timestamp window to reduce replay risk.
+    if abs(current_timestamp - timestamp_seconds) > max_skew_seconds:
+        return False
+
+    return verify_export_webhook_signature(
+        webhook_secret=webhook_secret,
+        timestamp=timestamp,
+        raw_body=raw_body,
+        signature=signature,
+    )

indream_client-0.1.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: indream-client
+Version: 0.1.1
+Summary: Official Python client for Indream Open API
+Project-URL: Homepage, https://github.com/indreamai/indream-client-python
+Project-URL: Repository, https://github.com/indreamai/indream-client-python
+Project-URL: Issues, https://github.com/indreamai/indream-client-python/issues
+Author: Indream
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: pydantic<3.0.0,>=2.9.0
+Provides-Extra: dev
+Requires-Dist: mypy<2.0.0,>=1.13.0; extra == 'dev'
+Requires-Dist: pytest<9.0.0,>=8.3.0; extra == 'dev'
+Requires-Dist: ruff<0.10.0,>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# indream-client
+
+Official Python client for the Indream Open API.
+
+- API docs: https://docs.indream.ai
+- Supports Python 3.10+
+
+## Installation
+
+```bash
+pip install indream-client
+```
+
+## Quick Start
+
+```python
+from indream import IndreamClient
+
+client = IndreamClient(api_key="YOUR_INDREAM_API_KEY")
+
+created = client.exports.create(
+    {
+        "editorState": editor_state,
+        "ratio": "9:16",
+        "scale": 0.6,
+        "fps": 30,
+        "format": "mp4",
+    }
+)
+
+task = client.exports.wait(created.task_id)
+print(task.status, task.output_url, task.duration_seconds, task.billed_standard_seconds)
+```

indream_client-0.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+indream/__init__.py,sha256=l8e59vIHORfwNPSshQdKoTBqET8jyiez_VYO-G1XT7U,481
+indream/async_client.py,sha256=z8n7AASc9wxXtq-z88Ap60wrnRTOgm52Rz3lTtS1ac4,6903
+indream/client.py,sha256=JuUvlzoBHdKIBPjX6UuguWt8PDfqgjQ8O69PMmDgI40,3616
+indream/errors.py,sha256=1YxBbotJCcARQZ2o1suUtnodJtUu-vi0pk8zAqQeD0k,1679
+indream/types.py,sha256=dD_ACdqgPaCs_DxEyqPL58muZI7R0QlOkEN1kHF-Pa0,2273
+indream/webhooks.py,sha256=WnoWPmdvkjD__IRvGN7v0lgcvIJImlAuu4tP5kK72Qo,2629
+indream/resources/__init__.py,sha256=CRcYDTGDql0LqcJyWH1zHmglD3W6L8_Sm3w48XgzNJs,20
+indream/resources/editor.py,sha256=YuYaI3yFOLXUaM10vpK8gNP_R3l41Dq3VBZKlDizQ6k,1402
+indream/resources/exports.py,sha256=nNS1JaWXdbgwxAp_WIXIBelVWpIFt72MlEpgMlCNmQk,3562
+indream_client-0.1.1.dist-info/METADATA,sha256=NhuBkagdJQ0q64qF4Bpd0NqziRUSmqIHu4RIKCPMHgo,1320
+indream_client-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+indream_client-0.1.1.dist-info/licenses/LICENSE,sha256=_GA8zJOuSL-VraB_nHnM0BtI4B4ZMVhqc74HgBe-rL4,1064
+indream_client-0.1.1.dist-info/RECORD,,

indream_client-0.1.1.dist-info/WHEEL

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

indream_client-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Indream
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.