ollang-sdk 0.1.0__tar.gz

ollang_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: ollang-sdk
+Version: 0.1.0
+Summary: Official Python SDK for the Ollang API - Translation, Transcription, Dubbing, Closed Captioning, and I18n Management
+Author: Ollang
+License: MIT
+Project-URL: Homepage, https://github.com/ollang/sdk
+Project-URL: Documentation, https://api-docs.ollang.com
+Project-URL: Repository, https://github.com/ollang/sdk
+Project-URL: Bug Tracker, https://github.com/ollang/sdk/issues
+Keywords: ollang,translation,transcription,dubbing,closed-captioning,subtitles,localization,sdk,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+
+# Ollang Python SDK
+
+Official Python SDK for the [Ollang API](https://api-docs.ollang.com) — translation, transcription, dubbing, closed captioning, and i18n management.
+
+## Installation
+
+```bash
+pip install ollang-sdk
+```
+
+Requires Python 3.8+.
+
+## Quick Start
+
+```python
+from ollang import Ollang
+
+client = Ollang(api_key="your-api-key")
+
+# Upload a file (creates a project)
+upload = client.uploads.direct(
+    "./video.mp4",
+    name="My Video",
+    source_language="en",
+)
+
+# Create an order
+orders = client.orders.create(
+    order_type="cc",
+    level=1,
+    project_id=upload["projectId"],
+    target_language_configs=[
+        {"language": "fr", "isRush": False},
+        {"language": "de", "isRush": False},
+    ],
+)
+
+# Check order status
+status = client.orders.get(orders[0]["orderId"])
+print(status)
+```
+
+Get your API key from your project settings at [Olabs](https://lab.ollang.com).
+
+## Resources
+
+| Resource                     | Description                            |
+| ---------------------------- | -------------------------------------- |
+| `client.projects`            | Read and list projects                 |
+| `client.uploads`             | Upload files (video, audio, documents) |
+| `client.orders`              | Create and track translation orders    |
+| `client.revisions`           | Request revisions on completed orders  |
+| `client.custom_instructions` | Set custom translation instructions    |
+
+All methods return the parsed JSON response as plain dicts/lists. Non-2xx
+responses raise `ollang.OllangAPIError`, which carries `status_code` and the
+parsed error `body`.
+
+## Examples
+
+```python
+# List orders with pagination and filters
+page = client.orders.list(page=1, take=20, status="completed")
+for order in page["data"]:
+    print(order["id"], order.get("status"))
+
+# Request a revision on an order
+client.revisions.create(
+    order_id="ORDER_ID",
+    type="wrongSubtitle",
+    time="00:01:23",
+    description="Fix the terminology in this segment",
+)
+
+# Custom instructions
+client.custom_instructions.create(
+    key="tone",
+    value="Formal, brand-safe tone for all marketing content",
+)
+
+# Endpoints not wrapped yet? Use the underlying HTTP client:
+languages = client.client.get("/integration/supported-languages")
+```
+
+## Configuration
+
+```python
+client = Ollang(
+    api_key="your-api-key",
+    base_url="https://api-integration.ollang.com",  # optional override
+    timeout=60.0,                                    # seconds
+)
+```
+
+## Development
+
+```bash
+cd python
+pip install -e . requests
+python -m unittest discover tests -v
+```
+
+## Documentation
+
+Full API documentation: **[https://api-docs.ollang.com](https://api-docs.ollang.com)**
+
+## License
+
+MIT

ollang_sdk-0.1.0/README.md

@@ -0,0 +1,109 @@
+# Ollang Python SDK
+
+Official Python SDK for the [Ollang API](https://api-docs.ollang.com) — translation, transcription, dubbing, closed captioning, and i18n management.
+
+## Installation
+
+```bash
+pip install ollang-sdk
+```
+
+Requires Python 3.8+.
+
+## Quick Start
+
+```python
+from ollang import Ollang
+
+client = Ollang(api_key="your-api-key")
+
+# Upload a file (creates a project)
+upload = client.uploads.direct(
+    "./video.mp4",
+    name="My Video",
+    source_language="en",
+)
+
+# Create an order
+orders = client.orders.create(
+    order_type="cc",
+    level=1,
+    project_id=upload["projectId"],
+    target_language_configs=[
+        {"language": "fr", "isRush": False},
+        {"language": "de", "isRush": False},
+    ],
+)
+
+# Check order status
+status = client.orders.get(orders[0]["orderId"])
+print(status)
+```
+
+Get your API key from your project settings at [Olabs](https://lab.ollang.com).
+
+## Resources
+
+| Resource                     | Description                            |
+| ---------------------------- | -------------------------------------- |
+| `client.projects`            | Read and list projects                 |
+| `client.uploads`             | Upload files (video, audio, documents) |
+| `client.orders`              | Create and track translation orders    |
+| `client.revisions`           | Request revisions on completed orders  |
+| `client.custom_instructions` | Set custom translation instructions    |
+
+All methods return the parsed JSON response as plain dicts/lists. Non-2xx
+responses raise `ollang.OllangAPIError`, which carries `status_code` and the
+parsed error `body`.
+
+## Examples
+
+```python
+# List orders with pagination and filters
+page = client.orders.list(page=1, take=20, status="completed")
+for order in page["data"]:
+    print(order["id"], order.get("status"))
+
+# Request a revision on an order
+client.revisions.create(
+    order_id="ORDER_ID",
+    type="wrongSubtitle",
+    time="00:01:23",
+    description="Fix the terminology in this segment",
+)
+
+# Custom instructions
+client.custom_instructions.create(
+    key="tone",
+    value="Formal, brand-safe tone for all marketing content",
+)
+
+# Endpoints not wrapped yet? Use the underlying HTTP client:
+languages = client.client.get("/integration/supported-languages")
+```
+
+## Configuration
+
+```python
+client = Ollang(
+    api_key="your-api-key",
+    base_url="https://api-integration.ollang.com",  # optional override
+    timeout=60.0,                                    # seconds
+)
+```
+
+## Development
+
+```bash
+cd python
+pip install -e . requests
+python -m unittest discover tests -v
+```
+
+## Documentation
+
+Full API documentation: **[https://api-docs.ollang.com](https://api-docs.ollang.com)**
+
+## License
+
+MIT

ollang_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ollang-sdk"
+version = "0.1.0"
+description = "Official Python SDK for the Ollang API - Translation, Transcription, Dubbing, Closed Captioning, and I18n Management"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Ollang" }]
+requires-python = ">=3.8"
+dependencies = ["requests>=2.25.0"]
+keywords = [
+    "ollang",
+    "translation",
+    "transcription",
+    "dubbing",
+    "closed-captioning",
+    "subtitles",
+    "localization",
+    "sdk",
+    "api",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/ollang/sdk"
+Documentation = "https://api-docs.ollang.com"
+Repository = "https://github.com/ollang/sdk"
+"Bug Tracker" = "https://github.com/ollang/sdk/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ollang_sdk-0.1.0/setup.cfg

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

ollang_sdk-0.1.0/src/ollang/__init__.py

@@ -0,0 +1,59 @@
+"""Official Python SDK for the Ollang API.
+
+Usage:
+
+    from ollang import Ollang
+
+    client = Ollang(api_key="your-api-key")
+    projects = client.projects.list()
+"""
+
+from typing import Any, Dict, Optional
+
+from ._client import DEFAULT_BASE_URL, OllangClient
+from ._exceptions import OllangAPIError, OllangError
+from .resources import CustomInstructions, Orders, Projects, Revisions, Uploads
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Ollang",
+    "OllangClient",
+    "OllangError",
+    "OllangAPIError",
+    "DEFAULT_BASE_URL",
+    "__version__",
+]
+
+
+class Ollang:
+    """Entry point for the Ollang API.
+
+    Args:
+        api_key: Your Ollang API key (from project settings at https://lab.ollang.com).
+        base_url: Override the API base URL. Defaults to the production
+            integration API.
+        timeout: Request timeout in seconds (default 60).
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+    ):
+        self._client = OllangClient(api_key=api_key, base_url=base_url, timeout=timeout)
+
+        self.orders = Orders(self._client)
+        self.projects = Projects(self._client)
+        self.revisions = Revisions(self._client)
+        self.uploads = Uploads(self._client)
+        self.custom_instructions = CustomInstructions(self._client)
+
+    def health_check(self) -> Dict[str, Any]:
+        return self._client.get("/health")
+
+    @property
+    def client(self) -> OllangClient:
+        """The underlying HTTP client, for calling endpoints not yet wrapped."""
+        return self._client

ollang_sdk-0.1.0/src/ollang/_client.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, Optional
+
+import requests
+
+from ._exceptions import OllangAPIError
+
+DEFAULT_BASE_URL = "https://api-integration.ollang.com"
+
+
+class OllangClient:
+    """Low-level HTTP client for the Ollang integration API.
+
+    Handles authentication (``X-Api-Key`` header), JSON encoding/decoding,
+    and error mapping. Resource classes build on top of this.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        session: Optional[requests.Session] = None,
+    ):
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self._session = session or requests.Session()
+        self._session.headers.update({"X-Api-Key": api_key})
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self._request("GET", path, params=params)
+
+    def post(self, path: str, json: Optional[Any] = None) -> Any:
+        return self._request("POST", path, json=json)
+
+    def patch(self, path: str, json: Optional[Any] = None) -> Any:
+        return self._request("PATCH", path, json=json)
+
+    def delete(self, path: str) -> Any:
+        return self._request("DELETE", path)
+
+    def post_multipart(self, path: str, files: Dict[str, Any], data: Dict[str, Any]) -> Any:
+        return self._request("POST", path, files=files, data=data)
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        url = self.base_url + path
+        response = self._session.request(method, url, timeout=self.timeout, **kwargs)
+
+        if not response.ok:
+            try:
+                body = response.json()
+            except ValueError:
+                body = response.text
+            raise OllangAPIError(
+                f"Ollang API request failed: {method} {path} -> {response.status_code}",
+                status_code=response.status_code,
+                body=body,
+            )
+
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return response.text

ollang_sdk-0.1.0/src/ollang/_exceptions.py

@@ -0,0 +1,20 @@
+from typing import Any, Optional
+
+
+class OllangError(Exception):
+    """Base exception for all Ollang SDK errors."""
+
+
+class OllangAPIError(OllangError):
+    """Raised when the Ollang API returns a non-2xx response.
+
+    Attributes:
+        status_code: HTTP status code of the response.
+        body: Parsed JSON body of the error response when available,
+            otherwise the raw response text.
+    """
+
+    def __init__(self, message: str, status_code: Optional[int] = None, body: Any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body

ollang_sdk-0.1.0/src/ollang/resources/__init__.py

@@ -0,0 +1,7 @@
+from .custom_instructions import CustomInstructions
+from .orders import Orders
+from .projects import Projects
+from .revisions import Revisions
+from .uploads import Uploads
+
+__all__ = ["CustomInstructions", "Orders", "Projects", "Revisions", "Uploads"]

ollang_sdk-0.1.0/src/ollang/resources/custom_instructions.py

@@ -0,0 +1,41 @@
+from typing import Any, Dict, List, Optional
+
+from .._client import OllangClient
+
+
+class CustomInstructions:
+    """Manage custom translation instructions."""
+
+    def __init__(self, client: OllangClient):
+        self._client = client
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self._client.get("/integration/custom-instructions")
+
+    def create(self, key: str, value: str, description: Optional[str] = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"key": key, "value": value}
+        if description is not None:
+            body["description"] = description
+        return self._client.post("/integration/custom-instructions", json=body)
+
+    def update(
+        self,
+        instruction_id: str,
+        key: Optional[str] = None,
+        value: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {}
+        if key is not None:
+            body["key"] = key
+        if value is not None:
+            body["value"] = value
+        if description is not None:
+            body["description"] = description
+        return self._client.patch(f"/integration/custom-instructions/{instruction_id}", json=body)
+
+    def delete(self, instruction_id: str) -> Any:
+        return self._client.delete(f"/integration/custom-instructions/{instruction_id}")
+
+    def suggestions(self) -> List[Dict[str, Any]]:
+        return self._client.get("/integration/custom-instructions/suggestions")

ollang_sdk-0.1.0/src/ollang/resources/orders.py

@@ -0,0 +1,119 @@
+from typing import Any, Dict, List, Optional
+
+from .._client import OllangClient
+
+
+class Orders:
+    """Create and track translation orders."""
+
+    def __init__(self, client: OllangClient):
+        self._client = client
+
+    def create(
+        self,
+        order_type: str,
+        level: int,
+        target_language_configs: List[Dict[str, Any]],
+        project_id: Optional[str] = None,
+        source_language: Optional[str] = None,
+        content: Optional[str] = None,
+        order_sub_type: Optional[str] = None,
+        dubbing_style: Optional[str] = None,
+        **extra: Any,
+    ) -> List[Dict[str, Any]]:
+        """Create one or more orders.
+
+        ``order_type`` is one of ``cc``, ``subtitle``, ``document``,
+        ``aiDubbing``, ``studioDubbing``, ``proofreading``, ``other`` or
+        ``revision``. Each entry of ``target_language_configs`` looks like
+        ``{"language": "fr", "isRush": False}``.
+
+        Returns the raw API response: a list of ``{"orderId": ..., "orderType": ...}``
+        entries (some order types create more than one order).
+        """
+        body: Dict[str, Any] = {
+            "orderType": order_type,
+            "level": level,
+            "targetLanguageConfigs": target_language_configs,
+        }
+        if project_id is not None:
+            body["projectId"] = project_id
+        if source_language is not None:
+            body["sourceLanguage"] = source_language
+        if content is not None:
+            body["content"] = content
+        if order_sub_type is not None:
+            body["orderSubType"] = order_sub_type
+        if dubbing_style is not None:
+            body["dubbingStyle"] = dubbing_style
+        body.update(extra)
+
+        return self._client.post("/integration/orders/create", json=body)
+
+    def list(
+        self,
+        page: Optional[int] = None,
+        take: Optional[int] = None,
+        search: Optional[str] = None,
+        order_by: Optional[str] = None,
+        order_direction: Optional[str] = None,
+        status: Optional[str] = None,
+        order_type: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """List orders with optional pagination and filters."""
+        params: Dict[str, Any] = {}
+        if page is not None:
+            params["pageOptions[page]"] = page
+        if take is not None:
+            params["pageOptions[take]"] = take
+        if search is not None:
+            params["pageOptions[search]"] = search
+        if order_by is not None:
+            params["pageOptions[orderBy]"] = order_by
+        if order_direction is not None:
+            params["pageOptions[orderDirection]"] = order_direction
+        if status is not None:
+            params["filter[status]"] = status
+        if order_type is not None:
+            params["filter[type]"] = order_type
+        if project_id is not None:
+            params["filter[projectId]"] = project_id
+
+        return self._client.get("/integration/orders", params=params)
+
+    def get(self, order_id: str) -> Dict[str, Any]:
+        return self._client.get(f"/integration/orders/{order_id}")
+
+    def cancel(self, order_id: str) -> Any:
+        return self._client.post(f"/integration/orders/cancel/{order_id}")
+
+    def request_human_review(self, order_id: str) -> Any:
+        return self._client.post(f"/integration/orders/{order_id}/human-review")
+
+    def run_qc_evaluation(
+        self,
+        order_id: str,
+        custom_prompt: Optional[str] = None,
+        accuracy: Optional[bool] = None,
+        fluency: Optional[bool] = None,
+        tone: Optional[bool] = None,
+        cultural_fit: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        body: Dict[str, Any] = {}
+        if custom_prompt is not None:
+            body["customPrompt"] = custom_prompt
+        if accuracy is not None:
+            body["accuracy"] = accuracy
+        if fluency is not None:
+            body["fluency"] = fluency
+        if tone is not None:
+            body["tone"] = tone
+        if cultural_fit is not None:
+            body["culturalFit"] = cultural_fit
+
+        return self._client.post(f"/integration/orders/{order_id}/qc", json=body or None)
+
+    def rerun(self, order_id: str, free_re_run: Optional[bool] = None) -> Dict[str, Any]:
+        body = {"freeReRun": free_re_run} if free_re_run is not None else None
+        return self._client.post(f"/integration/orders/{order_id}/rerun", json=body)

ollang_sdk-0.1.0/src/ollang/resources/projects.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, Optional
+
+from .._client import OllangClient
+
+
+class Projects:
+    """Read and list projects."""
+
+    def __init__(self, client: OllangClient):
+        self._client = client
+
+    def get(self, project_id: str) -> Dict[str, Any]:
+        return self._client.get(f"/integration/project/{project_id}")
+
+    def list(
+        self,
+        page: Optional[int] = None,
+        take: Optional[int] = None,
+        search: Optional[str] = None,
+        order_by: Optional[str] = None,
+        order_direction: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if page is not None:
+            params["page"] = page
+        if take is not None:
+            params["take"] = take
+        if search is not None:
+            params["search"] = search
+        if order_by is not None:
+            params["orderBy"] = order_by
+        if order_direction is not None:
+            params["orderDirection"] = order_direction
+
+        return self._client.get("/integration/project", params=params)

ollang_sdk-0.1.0/src/ollang/resources/revisions.py

@@ -0,0 +1,34 @@
+from typing import Any, Dict, List, Optional
+
+from .._client import OllangClient
+
+
+class Revisions:
+    """Request revisions on completed orders."""
+
+    def __init__(self, client: OllangClient):
+        self._client = client
+
+    def create(
+        self,
+        order_id: str,
+        type: str,
+        time: str,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a revision request for an order.
+
+        ``type`` is one of ``missingSubtitle``, ``wrongSubtitle``, ``syncError``,
+        ``formatError`` or ``other``. ``time`` is the timestamp the revision
+        refers to, e.g. ``"00:01:23"``.
+        """
+        body: Dict[str, Any] = {"type": type, "time": time}
+        if description is not None:
+            body["description"] = description
+        return self._client.post(f"/integration/revision/{order_id}", json=body)
+
+    def list(self, order_id: str) -> List[Dict[str, Any]]:
+        return self._client.get(f"/integration/revision/{order_id}")
+
+    def delete(self, order_id: str, revision_id: str) -> Any:
+        return self._client.delete(f"/integration/revision/{order_id}/{revision_id}")

ollang_sdk-0.1.0/src/ollang/resources/uploads.py

@@ -0,0 +1,65 @@
+import json
+import os
+from typing import Any, BinaryIO, Dict, List, Optional, Union
+
+from .._client import OllangClient
+
+FileInput = Union[str, os.PathLike, bytes, BinaryIO]
+
+
+def _as_file_tuple(file: FileInput, fallback_name: str):
+    """Normalize a path / bytes / file object into a (name, fileobj-or-bytes) tuple."""
+    if isinstance(file, (str, os.PathLike)):
+        path = os.fspath(file)
+        return (os.path.basename(path), open(path, "rb"))
+    if isinstance(file, bytes):
+        return (fallback_name, file)
+    name = getattr(file, "name", None)
+    return (os.path.basename(name) if isinstance(name, str) else fallback_name, file)
+
+
+class Uploads:
+    """Upload source files (video, audio, documents) and VTT subtitle files."""
+
+    def __init__(self, client: OllangClient):
+        self._client = client
+
+    def direct(
+        self,
+        file: FileInput,
+        name: str,
+        source_language: str,
+        notes: Optional[List[Dict[str, str]]] = None,
+    ) -> Dict[str, Any]:
+        """Upload a file directly, creating a project for it.
+
+        ``file`` can be a filesystem path, raw bytes, or an open binary file
+        object. ``notes`` entries look like
+        ``{"details": "...", "timeStamp": "00:01:23"}``.
+        """
+        filename, fileobj = _as_file_tuple(file, fallback_name=name)
+        data: Dict[str, Any] = {"name": name, "sourceLanguage": source_language}
+        if notes is not None:
+            data["notes"] = json.dumps(notes)
+        try:
+            return self._client.post_multipart(
+                "/integration/upload/direct",
+                files={"file": (filename, fileobj)},
+                data=data,
+            )
+        finally:
+            if isinstance(file, (str, os.PathLike)):
+                fileobj.close()
+
+    def vtt(self, file: FileInput, order_id: str) -> Dict[str, Any]:
+        """Upload a VTT subtitle file for an existing order."""
+        filename, fileobj = _as_file_tuple(file, fallback_name="subtitles.vtt")
+        try:
+            return self._client.post_multipart(
+                "/integration/upload/vtt",
+                files={"file": (filename, fileobj)},
+                data={"orderId": order_id},
+            )
+        finally:
+            if isinstance(file, (str, os.PathLike)):
+                fileobj.close()

ollang_sdk-0.1.0/src/ollang_sdk.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: ollang-sdk
+Version: 0.1.0
+Summary: Official Python SDK for the Ollang API - Translation, Transcription, Dubbing, Closed Captioning, and I18n Management
+Author: Ollang
+License: MIT
+Project-URL: Homepage, https://github.com/ollang/sdk
+Project-URL: Documentation, https://api-docs.ollang.com
+Project-URL: Repository, https://github.com/ollang/sdk
+Project-URL: Bug Tracker, https://github.com/ollang/sdk/issues
+Keywords: ollang,translation,transcription,dubbing,closed-captioning,subtitles,localization,sdk,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+
+# Ollang Python SDK
+
+Official Python SDK for the [Ollang API](https://api-docs.ollang.com) — translation, transcription, dubbing, closed captioning, and i18n management.
+
+## Installation
+
+```bash
+pip install ollang-sdk
+```
+
+Requires Python 3.8+.
+
+## Quick Start
+
+```python
+from ollang import Ollang
+
+client = Ollang(api_key="your-api-key")
+
+# Upload a file (creates a project)
+upload = client.uploads.direct(
+    "./video.mp4",
+    name="My Video",
+    source_language="en",
+)
+
+# Create an order
+orders = client.orders.create(
+    order_type="cc",
+    level=1,
+    project_id=upload["projectId"],
+    target_language_configs=[
+        {"language": "fr", "isRush": False},
+        {"language": "de", "isRush": False},
+    ],
+)
+
+# Check order status
+status = client.orders.get(orders[0]["orderId"])
+print(status)
+```
+
+Get your API key from your project settings at [Olabs](https://lab.ollang.com).
+
+## Resources
+
+| Resource                     | Description                            |
+| ---------------------------- | -------------------------------------- |
+| `client.projects`            | Read and list projects                 |
+| `client.uploads`             | Upload files (video, audio, documents) |
+| `client.orders`              | Create and track translation orders    |
+| `client.revisions`           | Request revisions on completed orders  |
+| `client.custom_instructions` | Set custom translation instructions    |
+
+All methods return the parsed JSON response as plain dicts/lists. Non-2xx
+responses raise `ollang.OllangAPIError`, which carries `status_code` and the
+parsed error `body`.
+
+## Examples
+
+```python
+# List orders with pagination and filters
+page = client.orders.list(page=1, take=20, status="completed")
+for order in page["data"]:
+    print(order["id"], order.get("status"))
+
+# Request a revision on an order
+client.revisions.create(
+    order_id="ORDER_ID",
+    type="wrongSubtitle",
+    time="00:01:23",
+    description="Fix the terminology in this segment",
+)
+
+# Custom instructions
+client.custom_instructions.create(
+    key="tone",
+    value="Formal, brand-safe tone for all marketing content",
+)
+
+# Endpoints not wrapped yet? Use the underlying HTTP client:
+languages = client.client.get("/integration/supported-languages")
+```
+
+## Configuration
+
+```python
+client = Ollang(
+    api_key="your-api-key",
+    base_url="https://api-integration.ollang.com",  # optional override
+    timeout=60.0,                                    # seconds
+)
+```
+
+## Development
+
+```bash
+cd python
+pip install -e . requests
+python -m unittest discover tests -v
+```
+
+## Documentation
+
+Full API documentation: **[https://api-docs.ollang.com](https://api-docs.ollang.com)**
+
+## License
+
+MIT

ollang_sdk-0.1.0/src/ollang_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/ollang/__init__.py
+src/ollang/_client.py
+src/ollang/_exceptions.py
+src/ollang/resources/__init__.py
+src/ollang/resources/custom_instructions.py
+src/ollang/resources/orders.py
+src/ollang/resources/projects.py
+src/ollang/resources/revisions.py
+src/ollang/resources/uploads.py
+src/ollang_sdk.egg-info/PKG-INFO
+src/ollang_sdk.egg-info/SOURCES.txt
+src/ollang_sdk.egg-info/dependency_links.txt
+src/ollang_sdk.egg-info/requires.txt
+src/ollang_sdk.egg-info/top_level.txt
+tests/test_client.py

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

@@ -0,0 +1 @@
+

ollang_sdk-0.1.0/src/ollang_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25.0

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

@@ -0,0 +1 @@
+ollang

ollang_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,142 @@
+import json
+import unittest
+
+from ollang import Ollang, OllangAPIError
+
+
+class FakeResponse:
+    def __init__(self, status_code=200, body=None):
+        self.status_code = status_code
+        self._body = body
+        self.content = b"" if body is None else json.dumps(body).encode()
+        self.text = "" if body is None else json.dumps(body)
+
+    @property
+    def ok(self):
+        return self.status_code < 400
+
+    def json(self):
+        if self._body is None:
+            raise ValueError("no body")
+        return self._body
+
+
+class FakeSession:
+    def __init__(self):
+        self.headers = {}
+        self.calls = []
+        self.next_response = FakeResponse(200, {"ok": True})
+
+    def request(self, method, url, **kwargs):
+        self.calls.append({"method": method, "url": url, **kwargs})
+        return self.next_response
+
+
+def make_client(session):
+    client = Ollang(api_key="test-key")
+    # Swap in the fake transport so no network is used.
+    client.client._session = session
+    session.headers.update({"X-Api-Key": "test-key"})
+    return client
+
+
+class ClientTests(unittest.TestCase):
+    def setUp(self):
+        self.session = FakeSession()
+        self.ollang = make_client(self.session)
+
+    def test_requires_api_key(self):
+        with self.assertRaises(ValueError):
+            Ollang(api_key="")
+
+    def test_health_check_url_and_auth(self):
+        self.ollang.health_check()
+        call = self.session.calls[0]
+        self.assertEqual(call["method"], "GET")
+        self.assertEqual(call["url"], "https://api-integration.ollang.com/health")
+        self.assertEqual(self.session.headers["X-Api-Key"], "test-key")
+
+    def test_custom_base_url_trailing_slash(self):
+        client = Ollang(api_key="k", base_url="https://example.com/")
+        client.client._session = self.session
+        client.health_check()
+        self.assertEqual(self.session.calls[0]["url"], "https://example.com/health")
+
+    def test_orders_create_body(self):
+        self.session.next_response = FakeResponse(200, [{"orderId": "o1"}])
+        result = self.ollang.orders.create(
+            order_type="cc",
+            level=1,
+            project_id="p1",
+            target_language_configs=[{"language": "fr", "isRush": False}],
+        )
+        call = self.session.calls[0]
+        self.assertEqual(call["method"], "POST")
+        self.assertTrue(call["url"].endswith("/integration/orders/create"))
+        self.assertEqual(
+            call["json"],
+            {
+                "orderType": "cc",
+                "level": 1,
+                "targetLanguageConfigs": [{"language": "fr", "isRush": False}],
+                "projectId": "p1",
+            },
+        )
+        self.assertEqual(result, [{"orderId": "o1"}])
+
+    def test_orders_list_params(self):
+        self.ollang.orders.list(page=2, take=10, status="completed", project_id="p1")
+        call = self.session.calls[0]
+        self.assertEqual(
+            call["params"],
+            {
+                "pageOptions[page]": 2,
+                "pageOptions[take]": 10,
+                "filter[status]": "completed",
+                "filter[projectId]": "p1",
+            },
+        )
+
+    def test_revisions_paths(self):
+        self.ollang.revisions.create("o1", type="wrongSubtitle", time="00:01:23", description="typo")
+        self.ollang.revisions.list("o1")
+        self.ollang.revisions.delete("o1", "r1")
+        self.assertTrue(self.session.calls[0]["url"].endswith("/integration/revision/o1"))
+        self.assertEqual(self.session.calls[1]["method"], "GET")
+        self.assertEqual(self.session.calls[2]["method"], "DELETE")
+        self.assertTrue(self.session.calls[2]["url"].endswith("/integration/revision/o1/r1"))
+
+    def test_upload_direct_multipart(self):
+        self.ollang.uploads.direct(
+            b"fake-bytes",
+            name="clip.mp4",
+            source_language="en",
+            notes=[{"details": "intro", "timeStamp": "00:00:01"}],
+        )
+        call = self.session.calls[0]
+        self.assertTrue(call["url"].endswith("/integration/upload/direct"))
+        self.assertIn("file", call["files"])
+        self.assertEqual(call["data"]["name"], "clip.mp4")
+        self.assertEqual(call["data"]["sourceLanguage"], "en")
+        self.assertEqual(
+            json.loads(call["data"]["notes"]),
+            [{"details": "intro", "timeStamp": "00:00:01"}],
+        )
+
+    def test_custom_instructions_update(self):
+        self.ollang.custom_instructions.update("ci1", value="new value")
+        call = self.session.calls[0]
+        self.assertEqual(call["method"], "PATCH")
+        self.assertTrue(call["url"].endswith("/integration/custom-instructions/ci1"))
+        self.assertEqual(call["json"], {"value": "new value"})
+
+    def test_api_error_raised(self):
+        self.session.next_response = FakeResponse(401, {"message": "invalid key"})
+        with self.assertRaises(OllangAPIError) as ctx:
+            self.ollang.projects.list()
+        self.assertEqual(ctx.exception.status_code, 401)
+        self.assertEqual(ctx.exception.body, {"message": "invalid key"})
+
+
+if __name__ == "__main__":
+    unittest.main()