From 275095b9306732ece993ed02bc63dc56a5c0d008 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 20:47:42 +0200 Subject: [PATCH 01/64] Add asyncio client support --- CHANGELOG.md | 1 + README.md | 20 +++ docs/source/index.rst | 19 ++ docs/source/transloadit.rst | 33 +++- poetry.lock | 2 +- pyproject.toml | 1 + tests/test_async_client.py | 316 ++++++++++++++++++++++++++++++++++ transloadit/async_assembly.py | 107 ++++++++++++ transloadit/async_client.py | 158 +++++++++++++++++ transloadit/async_request.py | 150 ++++++++++++++++ transloadit/async_template.py | 20 +++ transloadit/response.py | 28 ++- 12 files changed, 850 insertions(+), 5 deletions(-) create mode 100644 tests/test_async_client.py create mode 100644 transloadit/async_assembly.py create mode 100644 transloadit/async_client.py create mode 100644 transloadit/async_request.py create mode 100644 transloadit/async_template.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 631fabd..7cda431 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,6 @@ ### 2.0.0 / 2026-05-20 ### * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. +* Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. * Raised the runtime HTTP stack to patched versions by requiring `requests` 2.33+ and adding an explicit `urllib3` 2.7+ floor. * Updated development and documentation tooling, including `pytest` 9.0.3, `Sphinx` 9.1, `sphinx-autobuild` 2025.8, `coverage` 7.14, `tox` 4.54, and `requests-mock` 1.12. * Updated CI and local Docker test coverage to a representative Python 3.12, 3.13, and 3.14 matrix. diff --git a/README.md b/README.md index 51d6f4e..f97e803 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,26 @@ print(assembly_response.data.get('assembly_id')) print(assembly_response.data['assembly_id']) ``` +## Async usage + +```python +from transloadit.async_client import AsyncTransloadit + +async with AsyncTransloadit("TRANSLOADIT_KEY", "TRANSLOADIT_SECRET") as tl: + response = await tl.get_assembly(assembly_id="abc") + print(response.data["ok"]) + + assembly = tl.new_assembly() + assembly.add_step("resize", "/image/resize", {"width": 70, "height": 70}) + with open("PATH/TO/FILE.jpg", "rb") as upload: + assembly.add_file(upload) + response = await assembly.create(wait=True, resumable=False) +``` + +The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded with `asyncio.to_thread()` so the event loop stays responsive. + +If you do not use `async with`, call `await tl.aclose()` when you are done with the session. + ## Example For fully working examples, take a look at [`examples/`](https://github.com/transloadit/python-sdk/tree/HEAD/examples). diff --git a/docs/source/index.rst b/docs/source/index.rst index 67c428f..ac3ecd6 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -66,6 +66,25 @@ Usage # or print(assembly_response.data['assembly_id']) +Async usage +----------- + +.. code:: python + + from transloadit.async_client import AsyncTransloadit + + async with AsyncTransloadit('TRANSLOADIT_KEY', 'TRANSLOADIT_SECRET') as tl: + response = await tl.get_assembly(assembly_id='abc') + print(response.data['ok']) + + assembly = tl.new_assembly() + assembly.add_step('resize', '/image/resize', {'width': 70, 'height': 70}) + with open('PATH/TO/FILE.jpg', 'rb') as upload: + assembly.add_file(upload) + response = await assembly.create(wait=True, resumable=False) + +If you do not use ``async with``, call ``await tl.aclose()`` when you are done with the session. + Example ------- diff --git a/docs/source/transloadit.rst b/docs/source/transloadit.rst index b8e1a71..aba5aab 100644 --- a/docs/source/transloadit.rst +++ b/docs/source/transloadit.rst @@ -49,6 +49,38 @@ transloadit.request module :undoc-members: :show-inheritance: +transloadit.async_client module +------------------------------- + +.. automodule:: transloadit.async_client + :members: + :undoc-members: + :show-inheritance: + +transloadit.async_assembly module +---------------------------------- + +.. automodule:: transloadit.async_assembly + :members: + :undoc-members: + :show-inheritance: + +transloadit.async_template module +---------------------------------- + +.. automodule:: transloadit.async_template + :members: + :undoc-members: + :show-inheritance: + +transloadit.async_request module +-------------------------------- + +.. automodule:: transloadit.async_request + :members: + :undoc-members: + :show-inheritance: + transloadit.response module --------------------------- @@ -57,4 +89,3 @@ transloadit.response module :undoc-members: :show-inheritance: - diff --git a/poetry.lock b/poetry.lock index 3d496e1..087caf0 100644 --- a/poetry.lock +++ b/poetry.lock @@ -2012,4 +2012,4 @@ propcache = ">=0.2.1" [metadata] lock-version = "2.1" python-versions = ">=3.12" -content-hash = "722f633916f1df64f0091de35bb80488044c1d9ee3d20f840ba188756c9c7ada" +content-hash = "d929dd1019e9b2bdb1be768433f47c693177ed886d6c1975e76cb328a9a725c2" diff --git a/pyproject.toml b/pyproject.toml index cca89e8..53fbc49 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,6 +25,7 @@ classifiers = [ "Topic :: Multimedia :: Sound/Audio :: Conversion", ] dependencies = [ + "aiohttp>=3.13.5,<4", "requests>=2.33,<3", "tuspy>=1.0.0,<2.0.0", "urllib3>=2.7,<3", diff --git a/tests/test_async_client.py b/tests/test_async_client.py new file mode 100644 index 0000000..9b61380 --- /dev/null +++ b/tests/test_async_client.py @@ -0,0 +1,316 @@ +import asyncio +import json +from pathlib import Path +from unittest import IsolatedAsyncioTestCase, mock + +from aiohttp import web + +from transloadit.async_client import AsyncTransloadit +from transloadit.response import Response + + +class _AsyncApiServer: + def __init__(self): + self.requests = [] + self.app = web.Application() + self.app.router.add_get("/assemblies/{assembly_id}", self.handle_get_assembly) + self.app.router.add_get("/assemblies", self.handle_list_assemblies) + self.app.router.add_delete("/assemblies/{assembly_id}", self.handle_cancel_assembly) + self.app.router.add_get("/templates/{template_id}", self.handle_get_template) + self.app.router.add_get("/templates", self.handle_list_templates) + self.app.router.add_put("/templates/{template_id}", self.handle_update_template) + self.app.router.add_post("/templates", self.handle_create_template) + self.app.router.add_post("/assemblies", self.handle_create_assembly) + self.runner = None + self.site = None + self.base_url = None + + async def start(self): + self.runner = web.AppRunner(self.app) + await self.runner.setup() + self.site = web.TCPSite(self.runner, "127.0.0.1", 0) + await self.site.start() + + sock = self.site._server.sockets[0] + host, port = sock.getsockname()[:2] + self.base_url = f"http://{host}:{port}" + return self + + async def close(self): + if self.runner is not None: + await self.runner.cleanup() + + def _record(self, request, body=None): + entry = { + "method": request.method, + "path": request.path, + "query": dict(request.query), + "headers": dict(request.headers), + } + if body is not None: + entry["body"] = body + self.requests.append(entry) + return entry + + async def _parse_body(self, request): + post = await request.post() + body = {} + for key, value in post.items(): + if hasattr(value, "filename") and hasattr(value, "file"): + value.file.seek(0) + body[key] = { + "filename": value.filename, + "content": value.file.read(), + "content_type": value.content_type, + } + else: + body[key] = value + return body + + async def handle_get_assembly(self, request): + self._record(request) + return web.json_response( + { + "ok": "ASSEMBLY_COMPLETED", + "assembly_id": request.match_info["assembly_id"], + }, + headers={"X-Async-Route": "get_assembly"}, + ) + + async def handle_list_assemblies(self, request): + self._record(request) + return web.json_response( + {"items": [], "count": 0}, + headers={"X-Async-Route": "list_assemblies"}, + ) + + async def handle_cancel_assembly(self, request): + self._record(request) + return web.json_response( + { + "ok": "ASSEMBLY_CANCELED", + "assembly_id": request.match_info["assembly_id"], + }, + headers={"X-Async-Route": "cancel_assembly"}, + ) + + async def handle_get_template(self, request): + self._record(request) + return web.json_response( + { + "ok": "TEMPLATE_FOUND", + "template_id": request.match_info["template_id"], + }, + headers={"X-Async-Route": "get_template"}, + ) + + async def handle_list_templates(self, request): + self._record(request) + return web.json_response( + {"items": [{"template_id": "tpl-1"}], "count": 1}, + headers={"X-Async-Route": "list_templates"}, + ) + + async def handle_update_template(self, request): + body = await self._parse_body(request) + self._record(request, body) + return web.json_response( + { + "ok": "TEMPLATE_UPDATED", + "template_id": request.match_info["template_id"], + }, + headers={"X-Async-Route": "update_template"}, + ) + + async def handle_create_template(self, request): + body = await self._parse_body(request) + self._record(request, body) + params = json.loads(body["params"]) + return web.json_response( + { + "ok": "TEMPLATE_CREATED", + "template_name": params["name"], + }, + headers={"X-Async-Route": "create_template"}, + ) + + async def handle_create_assembly(self, request): + body = await self._parse_body(request) + self._record(request, body) + return web.json_response( + { + "ok": "ASSEMBLY_COMPLETED", + "assembly_id": "assembly-123", + "assembly_ssl_url": f"{self.base_url}/assemblies/assembly-123", + "tus_url": f"{self.base_url}/uploads", + }, + headers={"X-Async-Route": "create_assembly"}, + ) + + +class AsyncClientTest(IsolatedAsyncioTestCase): + async def asyncSetUp(self): + self.server = await _AsyncApiServer().start() + + async def asyncTearDown(self): + await self.server.close() + + async def test_async_client_methods_and_context_manager(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + response = await client.get_assembly(assembly_id="abc123") + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(response.data["assembly_id"], "abc123") + self.assertEqual(response.status_code, 200) + self.assertEqual(response.headers["X-Async-Route"], "get_assembly") + + response = await client.list_assemblies() + self.assertEqual(response.data["items"], []) + self.assertEqual(response.data["count"], 0) + self.assertEqual(response.headers["X-Async-Route"], "list_assemblies") + + response = await client.cancel_assembly(assembly_id="abc123") + self.assertEqual(response.data["ok"], "ASSEMBLY_CANCELED") + self.assertEqual(response.data["assembly_id"], "abc123") + + response = await client.get_template("tpl-1") + self.assertEqual(response.data["ok"], "TEMPLATE_FOUND") + self.assertEqual(response.data["template_id"], "tpl-1") + + response = await client.list_templates() + self.assertEqual(response.data["items"], [{"template_id": "tpl-1"}]) + self.assertEqual(response.data["count"], 1) + + response = await client.update_template("tpl-1", {"name": "foo_bar"}) + self.assertEqual(response.data["ok"], "TEMPLATE_UPDATED") + self.assertEqual(response.data["template_id"], "tpl-1") + + template = client.new_template("foo") + template.add_step("resize", "/image/resize", {"width": 70, "height": 70}) + response = await template.create() + self.assertEqual(response.data["ok"], "TEMPLATE_CREATED") + self.assertEqual(response.data["template_name"], "foo") + + self.assertIsNotNone(client.request.session) + self.assertTrue(client.request.session.closed) + + self.assertGreaterEqual(len(self.server.requests), 7) + first_request = self.server.requests[0] + self.assertEqual(first_request["method"], "GET") + self.assertEqual(first_request["path"], "/assemblies/abc123") + + update_request = next( + entry for entry in self.server.requests if entry["path"] == "/templates/tpl-1" and entry["method"] == "PUT" + ) + update_params = json.loads(update_request["body"]["params"]) + self.assertEqual(update_params["name"], "foo_bar") + + create_request = next( + entry for entry in self.server.requests if entry["path"] == "/templates" and entry["method"] == "POST" + ) + create_params = json.loads(create_request["body"]["params"]) + self.assertEqual(create_params["name"], "foo") + self.assertEqual(create_params["steps"]["resize"]["robot"], "/image/resize") + + async def test_async_assembly_create_non_resumable_upload(self): + fixture_path = Path(__file__).resolve().parents[1] / "LICENSE" + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_step("resize", "/image/resize", {"use": ":original", "width": 128}) + + with fixture_path.open("rb") as upload: + assembly.add_file(upload) + response = await assembly.create(resumable=False) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(response.data["assembly_id"], "assembly-123") + + create_request = next( + entry for entry in self.server.requests if entry["path"] == "/assemblies" and entry["method"] == "POST" + ) + create_params = json.loads(create_request["body"]["params"]) + self.assertEqual(create_params["steps"]["resize"]["robot"], "/image/resize") + self.assertIn("signature", create_request["body"]) + + uploaded_file = create_request["body"]["file"] + self.assertEqual(uploaded_file["filename"], "LICENSE") + self.assertEqual(uploaded_file["content"], fixture_path.read_bytes()) + + async def test_async_assembly_wait_polls_with_async_sleep(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0.25}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + completed = Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"}, + status_code=200, + headers={"X-Async-Route": "completed"}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)) as post_mock: + with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=completed)) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + post_mock.assert_awaited_once() + get_mock.assert_awaited_once_with( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ) + sleep_mock.assert_awaited_once_with(0.25) + + async def test_async_resumable_upload_uses_to_thread(self): + calls = [] + + class _Uploader: + def __init__(self, metadata): + self.metadata = metadata + + def upload(self): + calls.append(("upload", dict(self.metadata))) + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + self.tus_url = tus_url + + def uploader(self, **kwargs): + calls.append(("uploader", kwargs["metadata"], kwargs["chunk_size"], kwargs["retries"])) + return _Uploader(kwargs["metadata"]) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + "tus_url": f"{self.server.base_url}/uploads", + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)): + with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + with Path(__file__).resolve().parents[1].joinpath("README.md").open("rb") as upload: + assembly.add_file(upload) + response = await assembly.create(resumable=True, retries=5) + + self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") + to_thread_mock.assert_awaited_once() + self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) + self.assertEqual(calls[1][0], "uploader") + metadata = calls[1][1] + self.assertEqual(metadata["assembly_url"], f"{self.server.base_url}/assemblies/assembly-123") + self.assertEqual(metadata["fieldname"], "file") + self.assertEqual(metadata["filename"], "README.md") + self.assertEqual(calls[2][0], "upload") diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py new file mode 100644 index 0000000..514795d --- /dev/null +++ b/transloadit/async_assembly.py @@ -0,0 +1,107 @@ +import asyncio +import os + +from tusclient import client as tus + +from . import optionbuilder + + +class AsyncAssembly(optionbuilder.OptionBuilder): + """ + Object representation of a new Assembly to be created asynchronously. + """ + + def __init__(self, transloadit, files=None, options=None): + super().__init__(options) + self.transloadit = transloadit + self.files = files or {} + + def add_file(self, file_stream, field_name=None): + """ + Add a file to be uploaded along with the Assembly. + """ + if field_name is None: + field_name = self._get_field_name() + + self.files[field_name] = file_stream + + def _get_field_name(self): + name = "file" + if name not in self.files: + return name + + counter = 1 + while f"{name}_{counter}" in self.files: + counter += 1 + return f"{name}_{counter}" + + def remove_file(self, field_name): + """ + Remove the file with the specified field name from the set of files to be submitted. + """ + self.files.pop(field_name) + + def _do_tus_upload(self, assembly_url, tus_url, retries): + tus_client = tus.TusClient(tus_url) + for key, file_stream in self.files.items(): + metadata = { + "assembly_url": assembly_url, + "fieldname": key, + "filename": os.path.basename(file_stream.name), + } + tus_client.uploader( + file_stream=file_stream, + chunk_size=5 * 1024 * 1024, + metadata=metadata, + retries=retries, + ).upload() + + async def _do_tus_upload_async(self, assembly_url, tus_url, retries): + await asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) + + async def create(self, wait=False, resumable=True, retries=3): + """ + Save/Submit the assembly for processing. + """ + data = self.get_options() + if resumable: + extra_data = {"tus_num_expected_upload_files": len(self.files)} + response = await self.transloadit.request.post( + "/assemblies", extra_data=extra_data, data=data + ) + await self._do_tus_upload_async( + response.data.get("assembly_ssl_url"), + response.data.get("tus_url"), + retries, + ) + else: + response = await self.transloadit.request.post( + "/assemblies", data=data, files=self.files + ) + + if wait: + while not self._assembly_finished(response): + sleep_time = response.data.get("info", {}).get("retryIn", 1) + await asyncio.sleep(sleep_time) + response = await self.transloadit.get_assembly( + assembly_url=response.data.get("assembly_ssl_url") + ) + + if self._rate_limit_reached(response) and retries: + await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) + return await self.create(wait, resumable, retries - 1) + + return response + + def _assembly_finished(self, response): + status = response.data.get("ok") + is_aborted = status == "REQUEST_ABORTED" + is_canceled = status == "ASSEMBLY_CANCELED" + is_completed = status == "ASSEMBLY_COMPLETED" + error = response.data.get("error") + is_failed = error is not None + is_fetch_rate_limit = error == "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED" + return is_aborted or is_canceled or is_completed or (is_failed and not is_fetch_rate_limit) + + def _rate_limit_reached(self, response): + return response.data.get("error") == "RATE_LIMIT_REACHED" diff --git a/transloadit/async_client.py b/transloadit/async_client.py new file mode 100644 index 0000000..be6182b --- /dev/null +++ b/transloadit/async_client.py @@ -0,0 +1,158 @@ +import hashlib +import hmac +import time +from typing import List, Optional, Union +from urllib.parse import quote_plus, urlencode + +from . import async_assembly, async_request, async_template + + +class AsyncTransloadit: + """ + Asynchronous client interface to the Transloadit API. + """ + + def __init__( + self, + auth_key: str, + auth_secret: str, + service: str = "https://api2.transloadit.com", + duration: int = 300, + session=None, + ): + if not service.startswith(("http://", "https://")): + service = "https://" + service + + self.service = service + self.auth_key = auth_key + self.auth_secret = auth_secret + self.duration = duration + self.request = async_request.AsyncRequest(self, session=session) + + async def __aenter__(self): + await self.request._ensure_session() + return self + + async def __aexit__(self, exc_type, exc, tb): + await self.aclose() + + async def aclose(self): + await self.request.aclose() + + async def close(self): + await self.aclose() + + def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: + """ + Return an instance of . + """ + return async_assembly.AsyncAssembly(self, options=params) + + async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): + """ + Get the assembly specified by the 'assembly_id' or the 'assembly_url'. + """ + if not (assembly_id or assembly_url): + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + + url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + return await self.request.get(url) + + async def list_assemblies(self, params: dict = None): + """ + Get the list of assemblies. + """ + return await self.request.get("/assemblies", params=params) + + async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): + """ + Cancel the assembly specified by the 'assembly_id' or the 'assembly_url'. + """ + if not (assembly_id or assembly_url): + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + + url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + return await self.request.delete(url) + + async def get_template(self, template_id: str): + """ + Get the template specified by the 'template_id'. + """ + return await self.request.get(f"/templates/{template_id}") + + async def list_templates(self, params: Optional[dict] = None): + """ + Get the list of templates. + """ + return await self.request.get("/templates", params=params) + + def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: + """ + Return an instance of . + """ + return async_template.AsyncTemplate(self, name, options=params) + + async def update_template(self, template_id: str, data: dict): + """ + Update the template specified by the 'template_id'. + """ + return await self.request.put(f"/templates/{template_id}", data=data) + + async def delete_template(self, template_id: str): + """ + Delete the template specified by the 'template_id'. + """ + return await self.request.delete(f"/templates/{template_id}") + + async def get_bill(self, month: int, year: int): + """ + Get the bill for the specified month and year. + """ + return await self.request.get(f"/bill/{year}-{month:02d}") + + def get_signed_smart_cdn_url( + self, + workspace: str, + template: str, + input: str, + url_params: Optional[dict[str, Union[str, int, float, bool, List[Union[str, int, float, bool]], None]]] = None, + expires_at_ms: Optional[int] = None, + ) -> str: + """ + Construct a signed Smart CDN URL. + """ + workspace_slug = quote_plus(workspace) + template_slug = quote_plus(template) + input_field = quote_plus(input) + + expiry = expires_at_ms if expires_at_ms is not None else int(time.time() * 1000) + 60 * 60 * 1000 + + params = [] + if url_params: + for k, v in url_params.items(): + if v is None: + continue + elif isinstance(v, (str, int, float, bool)): + params.append((k, str(v))) + elif isinstance(v, (list, tuple)): + params.append((k, [str(vv) for vv in v])) + else: + raise ValueError( + f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}" + ) + + params.append(("auth_key", self.auth_key)) + params.append(("exp", str(expiry))) + sorted_params = sorted(params, key=lambda x: x[0]) + query_string = urlencode(sorted_params, doseq=True) + + string_to_sign = f"{workspace_slug}/{template_slug}/{input_field}?{query_string}" + algorithm = "sha256" + + signature = algorithm + ":" + hmac.new( + self.auth_secret.encode("utf-8"), + string_to_sign.encode("utf-8"), + hashlib.sha256, + ).hexdigest() + + return f"https://{workspace_slug}.tlcdn.com/{template_slug}/{input_field}?{query_string}&sig={quote_plus(signature)}" diff --git a/transloadit/async_request.py b/transloadit/async_request.py new file mode 100644 index 0000000..2f9164e --- /dev/null +++ b/transloadit/async_request.py @@ -0,0 +1,150 @@ +import os +import copy +import hashlib +import hmac +import json +from datetime import datetime, timedelta, timezone + +import aiohttp + +from . import __version__ +from .response import Response + +TIMEOUT = 60 + + +class AsyncRequest: + """ + Transloadit tailored asynchronous HTTP request object. + """ + + HEADERS = {"Transloadit-Client": "python-sdk:" + __version__} + + def __init__(self, transloadit, session=None): + self.transloadit = transloadit + self._session = session + self._owns_session = session is None + + @property + def session(self): + return self._session + + async def _ensure_session(self): + if self._session is None or self._session.closed: + self._session = aiohttp.ClientSession() + self._owns_session = True + return self._session + + async def aclose(self): + if self._session is not None and not self._session.closed and self._owns_session: + await self._session.close() + + def _normalize_payload(self, data): + return {key: str(value) for key, value in data.items()} + + async def get(self, path, params=None): + """ + Makes an asynchronous HTTP GET request. + """ + session = await self._ensure_session() + async with session.get( + self._get_full_url(path), + params=self._to_payload(params), + headers=self.HEADERS, + timeout=aiohttp.ClientTimeout(total=TIMEOUT), + ) as response: + return Response( + data=await response.json(), + status_code=response.status, + headers=response.headers, + ) + + async def post(self, path, data=None, extra_data=None, files=None): + """ + Makes an asynchronous HTTP POST request. + """ + session = await self._ensure_session() + data = self._to_payload(data) + if extra_data: + data.update(extra_data) + + if files: + form = aiohttp.FormData() + for key, value in self._normalize_payload(data).items(): + form.add_field(key, value) + + for key, file_stream in files.items(): + filename = os.path.basename(getattr(file_stream, "name", key)) or key + form.add_field(key, file_stream, filename=filename) + payload = form + else: + payload = self._normalize_payload(data) + + async with session.post( + self._get_full_url(path), + data=payload, + headers=self.HEADERS, + timeout=aiohttp.ClientTimeout(total=TIMEOUT), + ) as response: + return Response( + data=await response.json(), + status_code=response.status, + headers=response.headers, + ) + + async def put(self, path, data=None): + """ + Makes an asynchronous HTTP PUT request. + """ + session = await self._ensure_session() + data = self._normalize_payload(self._to_payload(data)) + async with session.put( + self._get_full_url(path), + data=data, + headers=self.HEADERS, + timeout=aiohttp.ClientTimeout(total=TIMEOUT), + ) as response: + return Response( + data=await response.json(), + status_code=response.status, + headers=response.headers, + ) + + async def delete(self, path, data=None): + """ + Makes an asynchronous HTTP DELETE request. + """ + session = await self._ensure_session() + data = self._normalize_payload(self._to_payload(data)) + async with session.delete( + self._get_full_url(path), + data=data, + headers=self.HEADERS, + timeout=aiohttp.ClientTimeout(total=TIMEOUT), + ) as response: + return Response( + data=await response.json(), + status_code=response.status, + headers=response.headers, + ) + + def _to_payload(self, data): + data = copy.deepcopy(data or {}) + expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) + data["auth"] = { + "key": self.transloadit.auth_key, + "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"), + } + json_data = json.dumps(data) + return {"params": json_data, "signature": self._sign_data(json_data)} + + def _sign_data(self, message): + hash_string = hmac.new( + self.transloadit.auth_secret.encode("utf-8"), message.encode("utf-8"), hashlib.sha384 + ).hexdigest() + return f"sha384:{hash_string}" + + def _get_full_url(self, url): + if url.startswith(("http://", "https://")): + return url + return self.transloadit.service + url diff --git a/transloadit/async_template.py b/transloadit/async_template.py new file mode 100644 index 0000000..34b2488 --- /dev/null +++ b/transloadit/async_template.py @@ -0,0 +1,20 @@ +from . import optionbuilder + + +class AsyncTemplate(optionbuilder.OptionBuilder): + """ + Object representation of a new Template to be created asynchronously. + """ + + def __init__(self, transloadit, name, options=None): + super().__init__(options) + self.transloadit = transloadit + self.name = name + + async def create(self): + """ + Save/Submit the template to the Transloadit server. + """ + data = self.get_options() + data.update({"name": self.name}) + return await self.transloadit.request.post("/templates", data=data) diff --git a/transloadit/response.py b/transloadit/response.py index 6eb7f52..a433881 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -1,13 +1,18 @@ from functools import wraps +_MISSING = object() + + class Response: """ Transloadit http Response Object :Attributes: - data (dict): - Dictionary representation of the returned JSON data. + Dictionary representation of the returned JSON data. For async + responses, this can also be preloaded data provided by the async + request layer. - status_code (int): HTTP response status code - headers (dict): @@ -15,17 +20,32 @@ class Response: :Constructor Args: - response (): The bare response object from the requests library. + - data (Optional[dict]): Preloaded JSON data for async responses. + - status_code (Optional[int]): Preloaded HTTP status code for async responses. + - headers (Optional[dict]): Preloaded response headers for async responses. """ - def __init__(self, response): + def __init__(self, response=None, data=_MISSING, status_code=_MISSING, headers=_MISSING): self._response = response - self.data = self._response.json() + self._data = data + self._status_code = status_code + self._headers = headers + + @property + def data(self): + if self._data is _MISSING: + if self._response is None: + return None + self._data = self._response.json() + return self._data @property def status_code(self): """ Return the http status code of the request. """ + if self._status_code is not _MISSING: + return self._status_code return self._response.status_code @property @@ -33,6 +53,8 @@ def headers(self): """ Return the response headers. """ + if self._headers is not _MISSING: + return self._headers return self._response.headers From 346818b46b89b128a27387c85ccd73727d7dec8e Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 20:59:28 +0200 Subject: [PATCH 02/64] Harden asyncio support --- tests/test_async_client.py | 196 ++++++++++++++++++++++++++++++++-- tests/test_response.py | 22 ++++ transloadit/async_assembly.py | 36 ++++++- transloadit/async_request.py | 25 +++-- transloadit/response.py | 6 ++ 5 files changed, 267 insertions(+), 18 deletions(-) create mode 100644 tests/test_response.py diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 9b61380..534713b 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -1,3 +1,4 @@ +import io import asyncio import json from pathlib import Path @@ -14,6 +15,7 @@ def __init__(self): self.requests = [] self.app = web.Application() self.app.router.add_get("/assemblies/{assembly_id}", self.handle_get_assembly) + self.app.router.add_get("/assemblies-text/{assembly_id}", self.handle_get_assembly_text) self.app.router.add_get("/assemblies", self.handle_list_assemblies) self.app.router.add_delete("/assemblies/{assembly_id}", self.handle_cancel_assembly) self.app.router.add_get("/templates/{template_id}", self.handle_get_template) @@ -77,6 +79,18 @@ async def handle_get_assembly(self, request): headers={"X-Async-Route": "get_assembly"}, ) + async def handle_get_assembly_text(self, request): + self._record(request) + payload = { + "ok": "ASSEMBLY_COMPLETED", + "assembly_id": request.match_info["assembly_id"], + } + return web.Response( + text=json.dumps(payload), + content_type="text/plain", + headers={"X-Async-Route": "get_assembly_text"}, + ) + async def handle_list_assemblies(self, request): self._record(request) return web.json_response( @@ -148,6 +162,41 @@ async def handle_create_assembly(self, request): ) +class _FakeResponseContext: + def __init__(self, payload): + self.payload = payload + self.status = 200 + self.headers = {"X-Async-Route": "fake"} + + async def __aenter__(self): + return self + + async def __aexit__(self, exc_type, exc, tb): + return False + + async def json(self, **kwargs): + return self.payload + + async def text(self): + if isinstance(self.payload, str): + return self.payload + return json.dumps(self.payload) + + +class _RecordingSession: + def __init__(self, payload): + self.calls = [] + self.closed = False + self.payload = payload + + def post(self, url, **kwargs): + self.calls.append((url, kwargs)) + return _FakeResponseContext(self.payload) + + async def close(self): + self.closed = True + + class AsyncClientTest(IsolatedAsyncioTestCase): async def asyncSetUp(self): self.server = await _AsyncApiServer().start() @@ -211,6 +260,16 @@ async def test_async_client_methods_and_context_manager(self): self.assertEqual(create_params["name"], "foo") self.assertEqual(create_params["steps"]["resize"]["robot"], "/image/resize") + async def test_async_client_accepts_json_with_text_content_type(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + response = await client.get_assembly( + assembly_url=f"{self.server.base_url}/assemblies-text/abc123" + ) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(response.data["assembly_id"], "abc123") + self.assertEqual(response.headers["X-Async-Route"], "get_assembly_text") + async def test_async_assembly_create_non_resumable_upload(self): fixture_path = Path(__file__).resolve().parents[1] / "LICENSE" @@ -249,6 +308,15 @@ async def test_async_assembly_wait_polls_with_async_sleep(self): status_code=200, headers={"X-Async-Route": "initial"}, ) + rate_limited = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + "info": {"retryIn": 0.25}, + }, + status_code=200, + headers={"X-Async-Route": "rate_limited"}, + ) completed = Response( data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"}, status_code=200, @@ -256,16 +324,129 @@ async def test_async_assembly_wait_polls_with_async_sleep(self): ) with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)) as post_mock: - with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=completed)) as get_mock: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(side_effect=[rate_limited, completed]), + ) as get_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: response = await assembly.create(wait=True, resumable=False) self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") post_mock.assert_awaited_once() - get_mock.assert_awaited_once_with( - assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + self.assertEqual( + get_mock.await_args_list, + [ + mock.call( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ), + mock.call( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ), + ], ) - sleep_mock.assert_awaited_once_with(0.25) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0.25), mock.call(0.25)]) + + async def test_async_assembly_resumable_rate_limit_retries_before_tus_upload(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + calls.append(("uploader", kwargs["metadata"])) + + class _Uploader: + def upload(self_inner): + calls.append(("upload", kwargs["metadata"])) + + return _Uploader() + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + upload = io.BytesIO(b"payload") + upload.name = "payload.bin" + assembly.add_file(upload) + + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + success = Response( + data={ + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + "tus_url": f"{self.server.base_url}/uploads", + }, + status_code=200, + headers={}, + ) + + with mock.patch.object( + client.request, + "post", + new=mock.AsyncMock(side_effect=[rate_limited, success]), + ) as post_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): + with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True, retries=2) + + self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") + self.assertEqual(post_mock.await_count, 2) + self.assertEqual(to_thread_mock.await_count, 1) + self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) + self.assertEqual(calls[1][0], "uploader") + + async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): + reads = [] + + async def fake_post(path, data=None, extra_data=None, files=None): + file_stream = files["file"] + reads.append(file_stream.read()) + if len(reads) == 1: + return Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + return Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"}, + status_code=200, + headers={}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(side_effect=fake_post)): + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(resumable=False, retries=2) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(reads, [b"payload", b"payload"]) + sleep_mock.assert_awaited_once_with(0) + + async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): + session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + upload = io.BytesIO(b"payload") + + response = await client.request.post("/assemblies", data={"foo": "bar"}, files={"file": upload}) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + timeout = session.calls[0][1]["timeout"] + self.assertIsNone(timeout.total) + self.assertEqual(timeout.sock_connect, 60) + self.assertEqual(timeout.sock_read, 60) async def test_async_resumable_upload_uses_to_thread(self): calls = [] @@ -301,9 +482,8 @@ def uploader(self, **kwargs): with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)): with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - with Path(__file__).resolve().parents[1].joinpath("README.md").open("rb") as upload: - assembly.add_file(upload) - response = await assembly.create(resumable=True, retries=5) + assembly.add_file(io.BytesIO(b"payload")) + response = await assembly.create(resumable=True, retries=5) self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") to_thread_mock.assert_awaited_once() @@ -312,5 +492,5 @@ def uploader(self, **kwargs): metadata = calls[1][1] self.assertEqual(metadata["assembly_url"], f"{self.server.base_url}/assemblies/assembly-123") self.assertEqual(metadata["fieldname"], "file") - self.assertEqual(metadata["filename"], "README.md") + self.assertEqual(metadata["filename"], "file") self.assertEqual(calls[2][0], "upload") diff --git a/tests/test_response.py b/tests/test_response.py new file mode 100644 index 0000000..2527164 --- /dev/null +++ b/tests/test_response.py @@ -0,0 +1,22 @@ +import unittest +from unittest import mock + +from transloadit.response import Response + + +class ResponseTest(unittest.TestCase): + def test_response_data_is_assignable_and_eager_for_sync_responses(self): + raw = mock.Mock() + raw.json.return_value = {"ok": "original"} + raw.status_code = 200 + raw.headers = {"X-Test": "1"} + + response = Response(raw) + + raw.json.assert_called_once() + + response.data = {"ok": "changed"} + + self.assertEqual(response.data, {"ok": "changed"}) + self.assertEqual(response.status_code, 200) + self.assertEqual(response.headers, {"X-Test": "1"}) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 514795d..a7d93d0 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -41,13 +41,33 @@ def remove_file(self, field_name): """ self.files.pop(field_name) + def _snapshot_file_positions(self): + positions = {} + for key, file_stream in self.files.items(): + try: + positions[key] = file_stream.tell() + except (AttributeError, OSError, ValueError): + continue + return positions + + def _rewind_files(self, positions): + for key, position in positions.items(): + file_stream = self.files.get(key) + if file_stream is None: + continue + try: + file_stream.seek(position) + except (AttributeError, OSError, ValueError): + continue + def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): + filename = getattr(file_stream, "name", key) metadata = { "assembly_url": assembly_url, "fieldname": key, - "filename": os.path.basename(file_stream.name), + "filename": os.path.basename(filename) or key, } tus_client.uploader( file_stream=file_stream, @@ -64,11 +84,16 @@ async def create(self, wait=False, resumable=True, retries=3): Save/Submit the assembly for processing. """ data = self.get_options() + file_positions = self._snapshot_file_positions() if resumable: extra_data = {"tus_num_expected_upload_files": len(self.files)} response = await self.transloadit.request.post( "/assemblies", extra_data=extra_data, data=data ) + if self._rate_limit_reached(response) and retries: + await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) + self._rewind_files(file_positions) + return await self.create(wait, resumable, retries - 1) await self._do_tus_upload_async( response.data.get("assembly_ssl_url"), response.data.get("tus_url"), @@ -78,17 +103,24 @@ async def create(self, wait=False, resumable=True, retries=3): response = await self.transloadit.request.post( "/assemblies", data=data, files=self.files ) + if self._rate_limit_reached(response) and retries: + await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) + self._rewind_files(file_positions) + return await self.create(wait, resumable, retries - 1) if wait: + assembly_url = response.data.get("assembly_ssl_url") while not self._assembly_finished(response): sleep_time = response.data.get("info", {}).get("retryIn", 1) await asyncio.sleep(sleep_time) response = await self.transloadit.get_assembly( - assembly_url=response.data.get("assembly_ssl_url") + assembly_url=assembly_url or response.data.get("assembly_ssl_url") ) + assembly_url = response.data.get("assembly_ssl_url") or assembly_url if self._rate_limit_reached(response) and retries: await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) + self._rewind_files(file_positions) return await self.create(wait, resumable, retries - 1) return response diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 2f9164e..b408cbe 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -39,9 +39,18 @@ async def aclose(self): if self._session is not None and not self._session.closed and self._owns_session: await self._session.close() + def _timeout(self): + return aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=TIMEOUT) + def _normalize_payload(self, data): return {key: str(value) for key, value in data.items()} + async def _read_response_data(self, response): + try: + return await response.json(content_type=None) + except (aiohttp.ContentTypeError, json.JSONDecodeError, UnicodeDecodeError): + return await response.text() + async def get(self, path, params=None): """ Makes an asynchronous HTTP GET request. @@ -51,10 +60,10 @@ async def get(self, path, params=None): self._get_full_url(path), params=self._to_payload(params), headers=self.HEADERS, - timeout=aiohttp.ClientTimeout(total=TIMEOUT), + timeout=self._timeout(), ) as response: return Response( - data=await response.json(), + data=await self._read_response_data(response), status_code=response.status, headers=response.headers, ) @@ -84,10 +93,10 @@ async def post(self, path, data=None, extra_data=None, files=None): self._get_full_url(path), data=payload, headers=self.HEADERS, - timeout=aiohttp.ClientTimeout(total=TIMEOUT), + timeout=self._timeout(), ) as response: return Response( - data=await response.json(), + data=await self._read_response_data(response), status_code=response.status, headers=response.headers, ) @@ -102,10 +111,10 @@ async def put(self, path, data=None): self._get_full_url(path), data=data, headers=self.HEADERS, - timeout=aiohttp.ClientTimeout(total=TIMEOUT), + timeout=self._timeout(), ) as response: return Response( - data=await response.json(), + data=await self._read_response_data(response), status_code=response.status, headers=response.headers, ) @@ -120,10 +129,10 @@ async def delete(self, path, data=None): self._get_full_url(path), data=data, headers=self.HEADERS, - timeout=aiohttp.ClientTimeout(total=TIMEOUT), + timeout=self._timeout(), ) as response: return Response( - data=await response.json(), + data=await self._read_response_data(response), status_code=response.status, headers=response.headers, ) diff --git a/transloadit/response.py b/transloadit/response.py index a433881..91c938d 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -27,6 +27,8 @@ class Response: def __init__(self, response=None, data=_MISSING, status_code=_MISSING, headers=_MISSING): self._response = response + if data is _MISSING and response is not None: + data = response.json() self._data = data self._status_code = status_code self._headers = headers @@ -39,6 +41,10 @@ def data(self): self._data = self._response.json() return self._data + @data.setter + def data(self, value): + self._data = value + @property def status_code(self): """ From 25f498ca3ba988c5cdc7499365ae50f2815d27a6 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:15:06 +0200 Subject: [PATCH 03/64] Improve async coverage --- tests/test_async_client.py | 300 +++++++++++++++++++++++++++++++++++++ tests/test_response.py | 14 ++ 2 files changed, 314 insertions(+) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 534713b..245fed2 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -7,6 +7,7 @@ from aiohttp import web from transloadit.async_client import AsyncTransloadit +from transloadit.client import Transloadit from transloadit.response import Response @@ -16,12 +17,15 @@ def __init__(self): self.app = web.Application() self.app.router.add_get("/assemblies/{assembly_id}", self.handle_get_assembly) self.app.router.add_get("/assemblies-text/{assembly_id}", self.handle_get_assembly_text) + self.app.router.add_get("/assemblies-plain/{assembly_id}", self.handle_get_assembly_plain) self.app.router.add_get("/assemblies", self.handle_list_assemblies) self.app.router.add_delete("/assemblies/{assembly_id}", self.handle_cancel_assembly) self.app.router.add_get("/templates/{template_id}", self.handle_get_template) + self.app.router.add_delete("/templates/{template_id}", self.handle_delete_template) self.app.router.add_get("/templates", self.handle_list_templates) self.app.router.add_put("/templates/{template_id}", self.handle_update_template) self.app.router.add_post("/templates", self.handle_create_template) + self.app.router.add_get("/bill/{year}-{month}", self.handle_get_bill) self.app.router.add_post("/assemblies", self.handle_create_assembly) self.runner = None self.site = None @@ -91,6 +95,14 @@ async def handle_get_assembly_text(self, request): headers={"X-Async-Route": "get_assembly_text"}, ) + async def handle_get_assembly_plain(self, request): + self._record(request) + return web.Response( + text="plain assembly response", + content_type="text/plain", + headers={"X-Async-Route": "get_assembly_plain"}, + ) + async def handle_list_assemblies(self, request): self._record(request) return web.json_response( @@ -118,6 +130,16 @@ async def handle_get_template(self, request): headers={"X-Async-Route": "get_template"}, ) + async def handle_delete_template(self, request): + self._record(request) + return web.json_response( + { + "ok": "TEMPLATE_DELETED", + "template_id": request.match_info["template_id"], + }, + headers={"X-Async-Route": "delete_template"}, + ) + async def handle_list_templates(self, request): self._record(request) return web.json_response( @@ -148,6 +170,16 @@ async def handle_create_template(self, request): headers={"X-Async-Route": "create_template"}, ) + async def handle_get_bill(self, request): + self._record(request) + return web.json_response( + { + "ok": "BILL_FOUND", + "period": f"{request.match_info['year']}-{request.match_info['month']}", + }, + headers={"X-Async-Route": "get_bill"}, + ) + async def handle_create_assembly(self, request): body = await self._parse_body(request) self._record(request, body) @@ -197,6 +229,27 @@ async def close(self): self.closed = True +class _NeverOwnedSession: + def __init__(self): + self.closed = False + self.close_calls = 0 + + async def close(self): + self.close_calls += 1 + self.closed = True + + +class _BrokenStream: + def __init__(self, name="broken.bin"): + self.name = name + + def tell(self): + raise OSError("tell failed") + + def seek(self, position): + raise OSError("seek failed") + + class AsyncClientTest(IsolatedAsyncioTestCase): async def asyncSetUp(self): self.server = await _AsyncApiServer().start() @@ -270,6 +323,106 @@ async def test_async_client_accepts_json_with_text_content_type(self): self.assertEqual(response.data["assembly_id"], "abc123") self.assertEqual(response.headers["X-Async-Route"], "get_assembly_text") + async def test_async_client_normalizes_service_and_rejects_missing_ids(self): + session = _NeverOwnedSession() + client = AsyncTransloadit( + "key", + "secret", + service="api2.transloadit.com", + session=session, + ) + + self.assertEqual(client.service, "https://api2.transloadit.com") + + with self.assertRaises(ValueError): + await client.get_assembly() + + with self.assertRaises(ValueError): + await client.cancel_assembly() + + await client.close() + + self.assertFalse(session.closed) + self.assertEqual(session.close_calls, 0) + + async def test_async_client_delete_template_get_bill_and_plain_text_fallback(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + response = await client.delete_template("tpl-1") + self.assertEqual(response.data["ok"], "TEMPLATE_DELETED") + self.assertEqual(response.data["template_id"], "tpl-1") + self.assertEqual(response.headers["X-Async-Route"], "delete_template") + + response = await client.get_bill(9, 2017) + self.assertEqual(response.data["ok"], "BILL_FOUND") + self.assertEqual(response.data["period"], "2017-09") + self.assertEqual(response.headers["X-Async-Route"], "get_bill") + + response = await client.get_assembly( + assembly_url=f"{self.server.base_url}/assemblies-plain/abc123" + ) + + self.assertEqual(response.data, "plain assembly response") + self.assertEqual(response.status_code, 200) + self.assertEqual(response.headers["X-Async-Route"], "get_assembly_plain") + + def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): + async_client = AsyncTransloadit("test-key", "test-secret") + sync_client = Transloadit("test-key", "test-secret") + params = {"width": 100, "tags": ["a", "b"], "enabled": True, "skip": None} + + with mock.patch("time.time", return_value=1732550672.867): + async_url = async_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + params, + ) + explicit_async_url = async_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + params, + expires_at_ms=1732550672867, + ) + sync_url = sync_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + params, + ) + explicit_sync_url = sync_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + params, + expires_at_ms=1732550672867, + ) + bare_async_url = async_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + ) + bare_sync_url = sync_client.get_signed_smart_cdn_url( + "Acme Workspace", + "My Template", + "folder/file name.jpg", + ) + + self.assertEqual(async_url, sync_url) + self.assertEqual(explicit_async_url, explicit_sync_url) + self.assertEqual(bare_async_url, bare_sync_url) + self.assertIn("auth_key=test-key", async_url) + self.assertIn("exp=1732554272867", async_url) + self.assertIn("width=100", async_url) + self.assertIn("tags=a", async_url) + self.assertIn("tags=b", async_url) + self.assertIn("exp=1732550672867", explicit_async_url) + self.assertNotIn("width=", bare_async_url) + self.assertNotIn("skip=", async_url) + + with self.assertRaises(ValueError): + async_client.get_signed_smart_cdn_url("workspace", "template", "input", {"bad": object()}) + async def test_async_assembly_create_non_resumable_upload(self): fixture_path = Path(__file__).resolve().parents[1] / "LICENSE" @@ -402,6 +555,112 @@ def upload(self_inner): self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") + async def test_async_resumable_upload_posts_extra_data_and_uses_tus_metadata(self): + calls = [] + + class _Uploader: + def __init__(self, metadata): + self.metadata = metadata + + def upload(self): + calls.append(("upload", dict(self.metadata))) + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + calls.append(("uploader", dict(kwargs["metadata"]))) + return _Uploader(kwargs["metadata"]) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + upload = io.BytesIO(b"payload") + upload.name = "" + assembly.add_file(upload, "explicit_field") + + with mock.patch( + "asyncio.to_thread", + new=mock.AsyncMock(side_effect=lambda func, *args: func(*args)), + ) as to_thread_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(to_thread_mock.await_count, 1) + + create_request = next( + entry for entry in self.server.requests if entry["path"] == "/assemblies" and entry["method"] == "POST" + ) + self.assertEqual(create_request["body"]["tus_num_expected_upload_files"], "1") + create_params = json.loads(create_request["body"]["params"]) + self.assertEqual(create_params["auth"]["key"], "key") + + self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) + self.assertEqual(calls[1][0], "uploader") + metadata = calls[1][1] + self.assertEqual(metadata["assembly_url"], f"{self.server.base_url}/assemblies/assembly-123") + self.assertEqual(metadata["fieldname"], "explicit_field") + self.assertEqual(metadata["filename"], "explicit_field") + self.assertEqual(calls[2][0], "upload") + + async def test_async_assembly_wait_retries_after_polling_rate_limit(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + rate_limited = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "rate_limited"}, + ) + completed = Response( + data={ + "ok": "ASSEMBLY_COMPLETED", + "assembly_id": "assembly-123", + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "completed"}, + ) + + with mock.patch.object( + client.request, + "post", + new=mock.AsyncMock(side_effect=[initial, initial]), + ) as post_mock: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(side_effect=[rate_limited, completed]), + ) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False, retries=2) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(post_mock.await_count, 2) + self.assertEqual( + get_mock.await_args_list, + [ + mock.call(assembly_url=f"{self.server.base_url}/assemblies/assembly-123"), + mock.call(assembly_url=f"{self.server.base_url}/assemblies/assembly-123"), + ], + ) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0), mock.call(0)]) + async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): reads = [] @@ -494,3 +753,44 @@ def uploader(self, **kwargs): self.assertEqual(metadata["fieldname"], "file") self.assertEqual(metadata["filename"], "file") self.assertEqual(calls[2][0], "upload") + + def test_async_assembly_helpers_cover_duplicate_names_and_rewind_edges(self): + client = AsyncTransloadit("key", "secret") + assembly = client.new_assembly() + + first = io.BytesIO(b"abc") + second = io.BytesIO(b"xyz") + third = io.BytesIO(b"456") + explicit = io.BytesIO(b"123") + + assembly.add_file(first) + assembly.add_file(second) + assembly.add_file(third) + assembly.add_file(explicit, "explicit") + + self.assertIs(assembly.files["file"], first) + self.assertIs(assembly.files["file_1"], second) + self.assertIs(assembly.files["file_2"], third) + self.assertIs(assembly.files["explicit"], explicit) + + assembly.remove_file("explicit") + self.assertIsNone(assembly.files.get("explicit")) + + first.read(1) + second.read(2) + positions = assembly._snapshot_file_positions() + self.assertEqual(positions["file"], 1) + self.assertEqual(positions["file_1"], 2) + + first.read(1) + second.read(1) + assembly._rewind_files(positions) + self.assertEqual(first.tell(), 1) + self.assertEqual(second.tell(), 2) + + broken = _BrokenStream() + assembly.files["broken"] = broken + positions = assembly._snapshot_file_positions() + self.assertNotIn("broken", positions) + + assembly._rewind_files({"missing": 4, "broken": 7}) diff --git a/tests/test_response.py b/tests/test_response.py index 2527164..28a8f76 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -20,3 +20,17 @@ def test_response_data_is_assignable_and_eager_for_sync_responses(self): self.assertEqual(response.data, {"ok": "changed"}) self.assertEqual(response.status_code, 200) self.assertEqual(response.headers, {"X-Test": "1"}) + + def test_response_supports_async_preloaded_values_and_empty_default(self): + empty = Response() + self.assertIsNone(empty.data) + + response = Response( + data={"ok": "async"}, + status_code=202, + headers={"X-Test": "1"}, + ) + + self.assertEqual(response.data, {"ok": "async"}) + self.assertEqual(response.status_code, 202) + self.assertEqual(response.headers, {"X-Test": "1"}) From 85697ba1620cc727d4c7fc4625915b3d6d35af3c Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:26:31 +0200 Subject: [PATCH 04/64] Fix async retry and response edge cases --- tests/test_async_client.py | 54 ++++++++++++++++++++++++++++++++--- tests/test_response.py | 2 ++ transloadit/async_assembly.py | 29 +++++++++---------- transloadit/async_request.py | 28 ++++++++++++------ transloadit/response.py | 4 +++ 5 files changed, 89 insertions(+), 28 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 245fed2..321910d 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -345,6 +345,18 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): self.assertFalse(session.closed) self.assertEqual(session.close_calls, 0) + closed_session = _NeverOwnedSession() + closed_session.closed = True + closed_client = AsyncTransloadit( + "key", + "secret", + service=self.server.base_url, + session=closed_session, + ) + + with self.assertRaises(RuntimeError): + await closed_client.get_assembly(assembly_id="abc123") + async def test_async_client_delete_template_get_bill_and_plain_text_fallback(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.delete_template("tpl-1") @@ -555,6 +567,39 @@ def upload(self_inner): self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") + async def test_async_assembly_resumable_rate_limit_returns_response_without_upload_when_retries_exhausted(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + raise AssertionError("TUS upload should not start when retries are exhausted") + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=rate_limited)) as post_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(resumable=True, retries=0) + + self.assertEqual(response.data["error"], "RATE_LIMIT_REACHED") + post_mock.assert_awaited_once() + sleep_mock.assert_not_awaited() + self.assertEqual(calls, []) + async def test_async_resumable_upload_posts_extra_data_and_uses_tus_metadata(self): calls = [] @@ -576,7 +621,7 @@ def uploader(self, **kwargs): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() upload = io.BytesIO(b"payload") - upload.name = "" + upload.name = None assembly.add_file(upload, "explicit_field") with mock.patch( @@ -651,7 +696,7 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self): response = await assembly.create(wait=True, resumable=False, retries=2) self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") - self.assertEqual(post_mock.await_count, 2) + self.assertEqual(post_mock.await_count, 1) self.assertEqual( get_mock.await_args_list, [ @@ -659,7 +704,7 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self): mock.call(assembly_url=f"{self.server.base_url}/assemblies/assembly-123"), ], ) - self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0), mock.call(0)]) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)]) async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): reads = [] @@ -698,6 +743,7 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) upload = io.BytesIO(b"payload") + upload.name = None response = await client.request.post("/assemblies", data={"foo": "bar"}, files={"file": upload}) @@ -705,7 +751,7 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): timeout = session.calls[0][1]["timeout"] self.assertIsNone(timeout.total) self.assertEqual(timeout.sock_connect, 60) - self.assertEqual(timeout.sock_read, 60) + self.assertIsNone(timeout.sock_read) async def test_async_resumable_upload_uses_to_thread(self): calls = [] diff --git a/tests/test_response.py b/tests/test_response.py index 28a8f76..f9cd0aa 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -24,6 +24,8 @@ def test_response_data_is_assignable_and_eager_for_sync_responses(self): def test_response_supports_async_preloaded_values_and_empty_default(self): empty = Response() self.assertIsNone(empty.data) + self.assertIsNone(empty.status_code) + self.assertIsNone(empty.headers) response = Response( data={"ok": "async"}, diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index a7d93d0..322cd2c 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -63,7 +63,7 @@ def _rewind_files(self, positions): def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): - filename = getattr(file_stream, "name", key) + filename = getattr(file_stream, "name", None) or key metadata = { "assembly_url": assembly_url, "fieldname": key, @@ -90,23 +90,24 @@ async def create(self, wait=False, resumable=True, retries=3): response = await self.transloadit.request.post( "/assemblies", extra_data=extra_data, data=data ) - if self._rate_limit_reached(response) and retries: + else: + response = await self.transloadit.request.post( + "/assemblies", data=data, files=self.files + ) + + if self._rate_limit_reached(response): + if retries: await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) self._rewind_files(file_positions) return await self.create(wait, resumable, retries - 1) + return response + + if resumable: await self._do_tus_upload_async( response.data.get("assembly_ssl_url"), response.data.get("tus_url"), retries, ) - else: - response = await self.transloadit.request.post( - "/assemblies", data=data, files=self.files - ) - if self._rate_limit_reached(response) and retries: - await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) - self._rewind_files(file_positions) - return await self.create(wait, resumable, retries - 1) if wait: assembly_url = response.data.get("assembly_ssl_url") @@ -118,11 +119,6 @@ async def create(self, wait=False, resumable=True, retries=3): ) assembly_url = response.data.get("assembly_ssl_url") or assembly_url - if self._rate_limit_reached(response) and retries: - await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) - self._rewind_files(file_positions) - return await self.create(wait, resumable, retries - 1) - return response def _assembly_finished(self, response): @@ -133,7 +129,8 @@ def _assembly_finished(self, response): error = response.data.get("error") is_failed = error is not None is_fetch_rate_limit = error == "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED" - return is_aborted or is_canceled or is_completed or (is_failed and not is_fetch_rate_limit) + is_submit_rate_limit = error == "RATE_LIMIT_REACHED" + return is_aborted or is_canceled or is_completed or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) def _rate_limit_reached(self, response): return response.data.get("error") == "RATE_LIMIT_REACHED" diff --git a/transloadit/async_request.py b/transloadit/async_request.py index b408cbe..aeafc34 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -1,3 +1,4 @@ +import asyncio import os import copy import hashlib @@ -24,23 +25,34 @@ def __init__(self, transloadit, session=None): self.transloadit = transloadit self._session = session self._owns_session = session is None + self._session_lock = asyncio.Lock() @property def session(self): return self._session async def _ensure_session(self): - if self._session is None or self._session.closed: - self._session = aiohttp.ClientSession() - self._owns_session = True - return self._session + async with self._session_lock: + if self._session is None: + self._session = aiohttp.ClientSession() + self._owns_session = True + elif self._session.closed: + if self._owns_session: + self._session = aiohttp.ClientSession() + else: + raise RuntimeError("Injected aiohttp session is closed.") + return self._session async def aclose(self): if self._session is not None and not self._session.closed and self._owns_session: await self._session.close() - def _timeout(self): - return aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=TIMEOUT) + def _timeout(self, files=False): + return aiohttp.ClientTimeout( + total=None, + sock_connect=TIMEOUT, + sock_read=None if files else TIMEOUT, + ) def _normalize_payload(self, data): return {key: str(value) for key, value in data.items()} @@ -83,7 +95,7 @@ async def post(self, path, data=None, extra_data=None, files=None): form.add_field(key, value) for key, file_stream in files.items(): - filename = os.path.basename(getattr(file_stream, "name", key)) or key + filename = os.path.basename(getattr(file_stream, "name", None) or key) or key form.add_field(key, file_stream, filename=filename) payload = form else: @@ -93,7 +105,7 @@ async def post(self, path, data=None, extra_data=None, files=None): self._get_full_url(path), data=payload, headers=self.HEADERS, - timeout=self._timeout(), + timeout=self._timeout(files=bool(files)), ) as response: return Response( data=await self._read_response_data(response), diff --git a/transloadit/response.py b/transloadit/response.py index 91c938d..1abf114 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -52,6 +52,8 @@ def status_code(self): """ if self._status_code is not _MISSING: return self._status_code + if self._response is None: + return None return self._response.status_code @property @@ -61,6 +63,8 @@ def headers(self): """ if self._headers is not _MISSING: return self._headers + if self._response is None: + return None return self._response.headers From 37e4cc57afa14e98aaa50a1ca936cff96aabb834 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:35:57 +0200 Subject: [PATCH 05/64] Handle plain-text async assembly responses --- tests/test_async_client.py | 68 +++++++++++++++++++++++++++++++++++ transloadit/async_assembly.py | 39 ++++++++++++-------- transloadit/async_request.py | 5 +-- 3 files changed, 96 insertions(+), 16 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 321910d..bc6652a 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -357,6 +357,21 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): with self.assertRaises(RuntimeError): await closed_client.get_assembly(assembly_id="abc123") + async def test_async_client_close_reopens_owned_session(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + + first_session = await client.request._ensure_session() + self.assertFalse(first_session.closed) + + await client.close() + self.assertTrue(first_session.closed) + + second_session = await client.request._ensure_session() + self.assertIsNot(first_session, second_session) + self.assertFalse(second_session.closed) + + await client.close() + async def test_async_client_delete_template_get_bill_and_plain_text_fallback(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.delete_template("tpl-1") @@ -377,6 +392,59 @@ async def test_async_client_delete_template_get_bill_and_plain_text_fallback(sel self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["X-Async-Route"], "get_assembly_plain") + async def test_async_assembly_create_returns_plain_text_response_without_crashing(self): + plain_response = Response( + data="plain assembly response", + status_code=502, + headers={"X-Async-Route": "plain"}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=plain_response)) as post_mock: + with mock.patch.object(client, "get_assembly", new=mock.AsyncMock()) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False) + + self.assertIs(response, plain_response) + self.assertEqual(response.data, "plain assembly response") + post_mock.assert_awaited_once() + get_mock.assert_not_awaited() + sleep_mock.assert_not_awaited() + + async def test_async_assembly_wait_returns_plain_text_poll_response_without_crashing(self): + initial_response = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + plain_response = Response( + data="plain assembly response", + status_code=502, + headers={"X-Async-Route": "plain"}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial_response)) as post_mock: + with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=plain_response)) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False) + + self.assertIs(response, plain_response) + self.assertEqual(response.data, "plain assembly response") + post_mock.assert_awaited_once() + get_mock.assert_awaited_once_with( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ) + sleep_mock.assert_awaited_once_with(0) + def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 322cd2c..63d621b 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -95,42 +95,53 @@ async def create(self, wait=False, resumable=True, retries=3): "/assemblies", data=data, files=self.files ) - if self._rate_limit_reached(response): + response_data = self._response_data(response) + if response_data is None: + return response + + if self._rate_limit_reached(response_data): if retries: - await asyncio.sleep(response.data.get("info", {}).get("retryIn", 1)) + await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) self._rewind_files(file_positions) return await self.create(wait, resumable, retries - 1) return response if resumable: await self._do_tus_upload_async( - response.data.get("assembly_ssl_url"), - response.data.get("tus_url"), + response_data.get("assembly_ssl_url"), + response_data.get("tus_url"), retries, ) if wait: - assembly_url = response.data.get("assembly_ssl_url") - while not self._assembly_finished(response): - sleep_time = response.data.get("info", {}).get("retryIn", 1) + assembly_url = response_data.get("assembly_ssl_url") + while not self._assembly_finished(response_data): + sleep_time = response_data.get("info", {}).get("retryIn", 1) await asyncio.sleep(sleep_time) response = await self.transloadit.get_assembly( - assembly_url=assembly_url or response.data.get("assembly_ssl_url") + assembly_url=assembly_url or response_data.get("assembly_ssl_url") ) - assembly_url = response.data.get("assembly_ssl_url") or assembly_url + response_data = self._response_data(response) + if response_data is None: + return response + assembly_url = response_data.get("assembly_ssl_url") or assembly_url return response - def _assembly_finished(self, response): - status = response.data.get("ok") + def _response_data(self, response): + data = response.data + return data if isinstance(data, dict) else None + + def _assembly_finished(self, response_data): + status = response_data.get("ok") is_aborted = status == "REQUEST_ABORTED" is_canceled = status == "ASSEMBLY_CANCELED" is_completed = status == "ASSEMBLY_COMPLETED" - error = response.data.get("error") + error = response_data.get("error") is_failed = error is not None is_fetch_rate_limit = error == "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED" is_submit_rate_limit = error == "RATE_LIMIT_REACHED" return is_aborted or is_canceled or is_completed or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) - def _rate_limit_reached(self, response): - return response.data.get("error") == "RATE_LIMIT_REACHED" + def _rate_limit_reached(self, response_data): + return response_data.get("error") == "RATE_LIMIT_REACHED" diff --git a/transloadit/async_request.py b/transloadit/async_request.py index aeafc34..ca1f3b3 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -44,8 +44,9 @@ async def _ensure_session(self): return self._session async def aclose(self): - if self._session is not None and not self._session.closed and self._owns_session: - await self._session.close() + async with self._session_lock: + if self._session is not None and not self._session.closed and self._owns_session: + await self._session.close() def _timeout(self, files=False): return aiohttp.ClientTimeout( From fb1bcfd59fc21f5b7b8ba400f8f4b17cbbe46ddb Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:44:54 +0200 Subject: [PATCH 06/64] Gate async TUS upload on successful create --- tests/test_async_client.py | 78 +++++++++++++++++++++++++++++++++++ transloadit/async_assembly.py | 18 +++++--- 2 files changed, 90 insertions(+), 6 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index bc6652a..c813dda 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -668,6 +668,84 @@ def uploader(self, **kwargs): sleep_mock.assert_not_awaited() self.assertEqual(calls, []) + async def test_async_assembly_resumable_error_response_skips_tus_upload(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + raise AssertionError("TUS upload should not start for error responses") + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + error_response = Response( + data={ + "error": "ASSEMBLY_NOT_AUTHORIZED", + }, + status_code=401, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=error_response)) as post_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True) + + self.assertIs(response, error_response) + post_mock.assert_awaited_once() + self.assertEqual(calls, []) + + async def test_async_assembly_resumable_response_without_upload_urls_skips_tus_upload(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + raise AssertionError("TUS upload should not start when upload URLs are missing") + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + incomplete_response = Response( + data={"ok": "ASSEMBLY_PROCESSING"}, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True) + + self.assertIs(response, incomplete_response) + post_mock.assert_awaited_once() + self.assertEqual(calls, []) + + async def test_async_assembly_wait_returns_response_without_assembly_url(self): + incomplete_response = Response( + data={"ok": "ASSEMBLY_PROCESSING"}, + status_code=200, + headers={}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock: + with mock.patch.object(client, "get_assembly", new=mock.AsyncMock()) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False) + + self.assertIs(response, incomplete_response) + post_mock.assert_awaited_once() + get_mock.assert_not_awaited() + sleep_mock.assert_not_awaited() + async def test_async_resumable_upload_posts_extra_data_and_uses_tus_metadata(self): calls = [] diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 63d621b..34d19c3 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -106,15 +106,21 @@ async def create(self, wait=False, resumable=True, retries=3): return await self.create(wait, resumable, retries - 1) return response + error = response_data.get("error") + assembly_url = response_data.get("assembly_ssl_url") + tus_url = response_data.get("tus_url") + + if error is not None: + return response + if resumable: - await self._do_tus_upload_async( - response_data.get("assembly_ssl_url"), - response_data.get("tus_url"), - retries, - ) + if not assembly_url or not tus_url: + return response + await self._do_tus_upload_async(assembly_url, tus_url, retries) if wait: - assembly_url = response_data.get("assembly_ssl_url") + if not assembly_url: + return response while not self._assembly_finished(response_data): sleep_time = response_data.get("info", {}).get("retryIn", 1) await asyncio.sleep(sleep_time) From def57f67fb87897491a29a41ea101dc68f1de0d7 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:52:30 +0200 Subject: [PATCH 07/64] Harden async retry rewinds --- tests/test_async_client.py | 90 ++++++++++++++++++++++++++++++++++- transloadit/async_assembly.py | 7 +-- 2 files changed, 93 insertions(+), 4 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index c813dda..91c1a9b 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -635,6 +635,67 @@ def upload(self_inner): self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") + async def test_async_assembly_resumable_rate_limit_skips_rewind_before_retrying(self): + calls = [] + + class _BrokenRewindStream(io.BytesIO): + def seek(self, position, *args, **kwargs): + raise OSError("seek failed") + + class _Uploader: + def __init__(self, metadata): + self.metadata = metadata + + def upload(self): + calls.append(("upload", dict(self.metadata))) + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + calls.append(("uploader", dict(kwargs["metadata"]))) + return _Uploader(kwargs["metadata"]) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + upload = _BrokenRewindStream(b"payload") + upload.name = "payload.bin" + assembly.add_file(upload) + + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + success = Response( + data={ + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + "tus_url": f"{self.server.base_url}/uploads", + }, + status_code=200, + headers={}, + ) + + with mock.patch.object( + client.request, + "post", + new=mock.AsyncMock(side_effect=[rate_limited, success]), + ) as post_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): + with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True, retries=2) + + self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") + self.assertEqual(post_mock.await_count, 2) + self.assertEqual(to_thread_mock.await_count, 1) + self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) + self.assertEqual(calls[1][0], "uploader") + async def test_async_assembly_resumable_rate_limit_returns_response_without_upload_when_retries_exhausted(self): calls = [] @@ -885,6 +946,31 @@ async def fake_post(path, data=None, extra_data=None, files=None): self.assertEqual(reads, [b"payload", b"payload"]) sleep_mock.assert_awaited_once_with(0) + async def test_async_assembly_non_resumable_rate_limit_raises_when_rewind_fails(self): + class _BrokenRewindStream(io.BytesIO): + def seek(self, position, *args, **kwargs): + raise OSError("seek failed") + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(_BrokenRewindStream(b"payload")) + + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=rate_limited)) as post_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): + with self.assertRaises(RuntimeError): + await assembly.create(resumable=False, retries=1) + + post_mock.assert_awaited_once() + async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) @@ -985,4 +1071,6 @@ def test_async_assembly_helpers_cover_duplicate_names_and_rewind_edges(self): positions = assembly._snapshot_file_positions() self.assertNotIn("broken", positions) - assembly._rewind_files({"missing": 4, "broken": 7}) + assembly._rewind_files({"missing": 4}) + with self.assertRaises(RuntimeError): + assembly._rewind_files({"broken": 7}) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 34d19c3..fcae1ba 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -57,8 +57,8 @@ def _rewind_files(self, positions): continue try: file_stream.seek(position) - except (AttributeError, OSError, ValueError): - continue + except (AttributeError, OSError, ValueError) as exc: + raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) @@ -102,7 +102,8 @@ async def create(self, wait=False, resumable=True, retries=3): if self._rate_limit_reached(response_data): if retries: await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) - self._rewind_files(file_positions) + if not resumable: + self._rewind_files(file_positions) return await self.create(wait, resumable, retries - 1) return response From 559b875a3a3ba0975179a35b6b3a6f3a1107fd3e Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 21:53:22 +0200 Subject: [PATCH 08/64] Fix resumable async wait and rewind retries --- tests/test_async_client.py | 40 +++++++++++++++++++++++++++++++++++ transloadit/async_assembly.py | 2 +- 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 91c1a9b..183e73f 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -580,6 +580,46 @@ async def test_async_assembly_wait_polls_with_async_sleep(self): ) self.assertEqual(sleep_mock.await_args_list, [mock.call(0.25), mock.call(0.25)]) + async def test_async_assembly_wait_polls_zero_file_resumable_assembly_without_tus(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0.25}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + completed = Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"}, + status_code=200, + headers={"X-Async-Route": "completed"}, + ) + + class _TusClient: + def __init__(self, tus_url): + raise AssertionError("TUS upload should not start for zero-file resumable assemblies") + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)) as post_mock: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(return_value=completed), + ) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(wait=True, resumable=True) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + post_mock.assert_awaited_once() + get_mock.assert_awaited_once_with( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0.25)]) + async def test_async_assembly_resumable_rate_limit_retries_before_tus_upload(self): calls = [] diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index fcae1ba..abfe3dd 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -114,7 +114,7 @@ async def create(self, wait=False, resumable=True, retries=3): if error is not None: return response - if resumable: + if resumable and self.files: if not assembly_url or not tus_url: return response await self._do_tus_upload_async(assembly_url, tus_url, retries) From f8d34823bf0ee1cdaf0b4fdb82628e0fe026589d Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 22:00:33 +0200 Subject: [PATCH 09/64] Refine async retries and upload metadata --- tests/test_async_client.py | 60 ++++++++++++++++++-- transloadit/async_assembly.py | 102 +++++++++++++++++++--------------- transloadit/async_request.py | 15 ++++- 3 files changed, 127 insertions(+), 50 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 183e73f..6d07eed 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -628,7 +628,7 @@ def __init__(self, tus_url): calls.append(("client", tus_url)) def uploader(self, **kwargs): - calls.append(("uploader", kwargs["metadata"])) + calls.append(("uploader", kwargs["metadata"], kwargs["retries"])) class _Uploader: def upload(self_inner): @@ -673,7 +673,7 @@ def upload(self_inner): self.assertEqual(post_mock.await_count, 2) self.assertEqual(to_thread_mock.await_count, 1) self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) - self.assertEqual(calls[1][0], "uploader") + self.assertEqual(calls[1], ("uploader", {"assembly_url": f"{self.server.base_url}/assemblies/assembly-123", "fieldname": "file", "filename": "payload.bin"}, 2)) async def test_async_assembly_resumable_rate_limit_skips_rewind_before_retrying(self): calls = [] @@ -868,7 +868,7 @@ def uploader(self, **kwargs): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() upload = io.BytesIO(b"payload") - upload.name = None + upload.name = 123 assembly.add_file(upload, "explicit_field") with mock.patch( @@ -953,6 +953,46 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self): ) self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)]) + async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhausted(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + rate_limited = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "rate_limited"}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)) as post_mock: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(return_value=rate_limited), + ) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False, retries=1) + + self.assertEqual(response.data["error"], "RATE_LIMIT_REACHED") + post_mock.assert_awaited_once() + get_mock.assert_awaited_once_with( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0)]) + async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): reads = [] @@ -1015,7 +1055,7 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) upload = io.BytesIO(b"payload") - upload.name = None + upload.name = "clip.jpg" response = await client.request.post("/assemblies", data={"foo": "bar"}, files={"file": upload}) @@ -1024,6 +1064,18 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): self.assertIsNone(timeout.total) self.assertEqual(timeout.sock_connect, 60) self.assertIsNone(timeout.sock_read) + self.assertEqual(session.calls[0][1]["data"]._fields[2][1]["Content-Type"], "image/jpeg") + + async def test_async_request_uses_filename_fallback_for_trailing_slash_stream_name(self): + session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + upload = io.BytesIO(b"payload") + upload.name = "/tmp/" + + response = await client.request.post("/assemblies", data={"foo": "bar"}, files={"file": upload}) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(session.calls[0][1]["data"]._fields[2][0]["filename"], "file") async def test_async_resumable_upload_uses_to_thread(self): calls = [] diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index abfe3dd..eb81ffd 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -1,9 +1,9 @@ import asyncio -import os from tusclient import client as tus from . import optionbuilder +from .async_request import _get_upload_filename class AsyncAssembly(optionbuilder.OptionBuilder): @@ -63,11 +63,11 @@ def _rewind_files(self, positions): def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): - filename = getattr(file_stream, "name", None) or key + filename = _get_upload_filename(file_stream, key) metadata = { "assembly_url": assembly_url, "fieldname": key, - "filename": os.path.basename(filename) or key, + "filename": filename, } tus_client.uploader( file_stream=file_stream, @@ -85,55 +85,69 @@ async def create(self, wait=False, resumable=True, retries=3): """ data = self.get_options() file_positions = self._snapshot_file_positions() - if resumable: - extra_data = {"tus_num_expected_upload_files": len(self.files)} - response = await self.transloadit.request.post( - "/assemblies", extra_data=extra_data, data=data - ) - else: - response = await self.transloadit.request.post( - "/assemblies", data=data, files=self.files - ) - - response_data = self._response_data(response) - if response_data is None: - return response + tus_retries = retries + poll_retries = retries + + while True: + if resumable: + extra_data = {"tus_num_expected_upload_files": len(self.files)} if self.files else None + response = await self.transloadit.request.post( + "/assemblies", extra_data=extra_data, data=data + ) + else: + response = await self.transloadit.request.post( + "/assemblies", data=data, files=self.files + ) - if self._rate_limit_reached(response_data): - if retries: - await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) - if not resumable: - self._rewind_files(file_positions) - return await self.create(wait, resumable, retries - 1) - return response + response_data = self._response_data(response) + if response_data is None: + return response - error = response_data.get("error") - assembly_url = response_data.get("assembly_ssl_url") - tus_url = response_data.get("tus_url") + if self._rate_limit_reached(response_data): + if retries: + await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) + if not resumable: + self._rewind_files(file_positions) + retries -= 1 + continue + return response - if error is not None: - return response + error = response_data.get("error") + assembly_url = response_data.get("assembly_ssl_url") + tus_url = response_data.get("tus_url") - if resumable and self.files: - if not assembly_url or not tus_url: + if error is not None: return response - await self._do_tus_upload_async(assembly_url, tus_url, retries) - if wait: - if not assembly_url: - return response - while not self._assembly_finished(response_data): - sleep_time = response_data.get("info", {}).get("retryIn", 1) - await asyncio.sleep(sleep_time) - response = await self.transloadit.get_assembly( - assembly_url=assembly_url or response_data.get("assembly_ssl_url") - ) - response_data = self._response_data(response) - if response_data is None: + if resumable and self.files: + if not assembly_url or not tus_url: return response - assembly_url = response_data.get("assembly_ssl_url") or assembly_url + await self._do_tus_upload_async(assembly_url, tus_url, tus_retries) - return response + if wait: + if not assembly_url: + return response + + poll_response = response + poll_data = response_data + remaining_polls = poll_retries + while not self._assembly_finished(poll_data): + if remaining_polls <= 0: + return poll_response + sleep_time = poll_data.get("info", {}).get("retryIn", 1) + await asyncio.sleep(sleep_time) + poll_response = await self.transloadit.get_assembly( + assembly_url=assembly_url or poll_data.get("assembly_ssl_url") + ) + poll_data = self._response_data(poll_response) + if poll_data is None: + return poll_response + assembly_url = poll_data.get("assembly_ssl_url") or assembly_url + remaining_polls -= 1 + + return poll_response + + return response def _response_data(self, response): data = response.data diff --git a/transloadit/async_request.py b/transloadit/async_request.py index ca1f3b3..8987fba 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -1,4 +1,5 @@ import asyncio +import mimetypes import os import copy import hashlib @@ -14,6 +15,15 @@ TIMEOUT = 60 +def _get_upload_filename(file_stream, fallback): + name = getattr(file_stream, "name", None) + if isinstance(name, (str, bytes, os.PathLike)): + filename = os.path.basename(name) + if filename: + return filename + return fallback + + class AsyncRequest: """ Transloadit tailored asynchronous HTTP request object. @@ -96,8 +106,9 @@ async def post(self, path, data=None, extra_data=None, files=None): form.add_field(key, value) for key, file_stream in files.items(): - filename = os.path.basename(getattr(file_stream, "name", None) or key) or key - form.add_field(key, file_stream, filename=filename) + filename = _get_upload_filename(file_stream, key) + content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" + form.add_field(key, file_stream, filename=filename, content_type=content_type) payload = form else: payload = self._normalize_payload(data) From 83ea871e7eaf920a4352f16c416fc497a8b6238c Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 22:06:50 +0200 Subject: [PATCH 10/64] Polish async retries and uploads --- tests/test_async_client.py | 51 ++++++++++++++++++++++++----------- transloadit/async_assembly.py | 13 ++++++--- transloadit/async_request.py | 21 +++++++++++---- 3 files changed, 61 insertions(+), 24 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 6d07eed..73b8491 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -392,7 +392,7 @@ async def test_async_client_delete_template_get_bill_and_plain_text_fallback(sel self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["X-Async-Route"], "get_assembly_plain") - async def test_async_assembly_create_returns_plain_text_response_without_crashing(self): + async def test_async_assembly_create_raises_on_plain_text_error_response(self): plain_response = Response( data="plain assembly response", status_code=502, @@ -403,17 +403,12 @@ async def test_async_assembly_create_returns_plain_text_response_without_crashin assembly = client.new_assembly() with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=plain_response)) as post_mock: - with mock.patch.object(client, "get_assembly", new=mock.AsyncMock()) as get_mock: - with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: - response = await assembly.create(wait=True, resumable=False) + with self.assertRaises(RuntimeError): + await assembly.create(wait=True, resumable=False) - self.assertIs(response, plain_response) - self.assertEqual(response.data, "plain assembly response") post_mock.assert_awaited_once() - get_mock.assert_not_awaited() - sleep_mock.assert_not_awaited() - async def test_async_assembly_wait_returns_plain_text_poll_response_without_crashing(self): + async def test_async_assembly_wait_raises_on_plain_text_poll_response(self): initial_response = Response( data={ "ok": "ASSEMBLY_PROCESSING", @@ -435,10 +430,9 @@ async def test_async_assembly_wait_returns_plain_text_poll_response_without_cras with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial_response)) as post_mock: with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=plain_response)) as get_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: - response = await assembly.create(wait=True, resumable=False) + with self.assertRaises(RuntimeError): + await assembly.create(wait=True, resumable=False) - self.assertIs(response, plain_response) - self.assertEqual(response.data, "plain assembly response") post_mock.assert_awaited_once() get_mock.assert_awaited_once_with( assembly_url=f"{self.server.base_url}/assemblies/assembly-123" @@ -988,10 +982,18 @@ async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhaus self.assertEqual(response.data["error"], "RATE_LIMIT_REACHED") post_mock.assert_awaited_once() - get_mock.assert_awaited_once_with( - assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + self.assertEqual( + get_mock.await_args_list, + [ + mock.call( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ), + mock.call( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ), + ], ) - self.assertEqual(sleep_mock.await_args_list, [mock.call(0)]) + self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)]) async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): reads = [] @@ -1066,6 +1068,25 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): self.assertIsNone(timeout.sock_read) self.assertEqual(session.calls[0][1]["data"]._fields[2][1]["Content-Type"], "image/jpeg") + async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data(self): + session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + upload = io.BytesIO(b"payload") + upload.name = "clip.jpg" + + response = await client.request.post( + "/assemblies", + data={"foo": "bar"}, + extra_data={"enabled": True, "skip": None}, + files={"file": upload}, + ) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + fields = {field[0]["name"]: field for field in session.calls[0][1]["data"]._fields} + self.assertIn("enabled", fields) + self.assertNotIn("skip", fields) + self.assertEqual(fields["enabled"][2], "true") + async def test_async_request_uses_filename_fallback_for_trailing_slash_stream_name(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index eb81ffd..2085a13 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -101,6 +101,8 @@ async def create(self, wait=False, resumable=True, retries=3): response_data = self._response_data(response) if response_data is None: + if response.status_code >= 400: + raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") return response if self._rate_limit_reached(response_data): @@ -130,10 +132,12 @@ async def create(self, wait=False, resumable=True, retries=3): poll_response = response poll_data = response_data - remaining_polls = poll_retries + remaining_rate_limit_retries = poll_retries while not self._assembly_finished(poll_data): - if remaining_polls <= 0: - return poll_response + if self._rate_limit_reached(poll_data): + if remaining_rate_limit_retries <= 0: + return poll_response + remaining_rate_limit_retries -= 1 sleep_time = poll_data.get("info", {}).get("retryIn", 1) await asyncio.sleep(sleep_time) poll_response = await self.transloadit.get_assembly( @@ -141,9 +145,10 @@ async def create(self, wait=False, resumable=True, retries=3): ) poll_data = self._response_data(poll_response) if poll_data is None: + if poll_response.status_code >= 400: + raise RuntimeError(f"Unexpected non-JSON response ({poll_response.status_code}).") return poll_response assembly_url = poll_data.get("assembly_ssl_url") or assembly_url - remaining_polls -= 1 return poll_response diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 8987fba..e8ebc33 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -41,6 +41,9 @@ def __init__(self, transloadit, session=None): def session(self): return self._session + def _headers(self): + return dict(self.HEADERS) + async def _ensure_session(self): async with self._session_lock: if self._session is None: @@ -66,7 +69,15 @@ def _timeout(self, files=False): ) def _normalize_payload(self, data): - return {key: str(value) for key, value in data.items()} + normalized = {} + for key, value in data.items(): + if value is None: + continue + if isinstance(value, bool): + normalized[key] = "true" if value else "false" + else: + normalized[key] = str(value) + return normalized async def _read_response_data(self, response): try: @@ -82,7 +93,7 @@ async def get(self, path, params=None): async with session.get( self._get_full_url(path), params=self._to_payload(params), - headers=self.HEADERS, + headers=self._headers(), timeout=self._timeout(), ) as response: return Response( @@ -116,7 +127,7 @@ async def post(self, path, data=None, extra_data=None, files=None): async with session.post( self._get_full_url(path), data=payload, - headers=self.HEADERS, + headers=self._headers(), timeout=self._timeout(files=bool(files)), ) as response: return Response( @@ -134,7 +145,7 @@ async def put(self, path, data=None): async with session.put( self._get_full_url(path), data=data, - headers=self.HEADERS, + headers=self._headers(), timeout=self._timeout(), ) as response: return Response( @@ -152,7 +163,7 @@ async def delete(self, path, data=None): async with session.delete( self._get_full_url(path), data=data, - headers=self.HEADERS, + headers=self._headers(), timeout=self._timeout(), ) as response: return Response( From 3cb1bb49057147257cb292767d1e3de08c201f11 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 22:19:17 +0200 Subject: [PATCH 11/64] Improve async coverage and retry safety --- tests/test_async_client.py | 105 ++++++++++++++++++++++++++++++++-- tests/test_response.py | 15 ++++- transloadit/async_assembly.py | 18 ++++-- transloadit/async_request.py | 23 ++++++-- 4 files changed, 146 insertions(+), 15 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 73b8491..b369f10 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -292,8 +292,7 @@ async def test_async_client_methods_and_context_manager(self): self.assertEqual(response.data["ok"], "TEMPLATE_CREATED") self.assertEqual(response.data["template_name"], "foo") - self.assertIsNotNone(client.request.session) - self.assertTrue(client.request.session.closed) + self.assertIsNone(client.request.session) self.assertGreaterEqual(len(self.server.requests), 7) first_request = self.server.requests[0] @@ -365,6 +364,7 @@ async def test_async_client_close_reopens_owned_session(self): await client.close() self.assertTrue(first_session.closed) + self.assertIsNone(client.request.session) second_session = await client.request._ensure_session() self.assertIsNot(first_session, second_session) @@ -372,6 +372,20 @@ async def test_async_client_close_reopens_owned_session(self): await client.close() + async def test_async_client_reopens_owned_session_when_session_is_closed(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + + first_session = await client.request._ensure_session() + self.assertFalse(first_session.closed) + + await first_session.close() + reopened_session = await client.request._ensure_session() + + self.assertIsNot(first_session, reopened_session) + self.assertFalse(reopened_session.closed) + + await client.close() + async def test_async_client_delete_template_get_bill_and_plain_text_fallback(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.delete_template("tpl-1") @@ -408,6 +422,22 @@ async def test_async_assembly_create_raises_on_plain_text_error_response(self): post_mock.assert_awaited_once() + async def test_async_assembly_create_returns_plain_text_success_response(self): + plain_response = Response( + data="plain assembly response", + status_code=200, + headers={"X-Async-Route": "plain"}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=plain_response)) as post_mock: + response = await assembly.create(wait=False, resumable=False) + + self.assertIs(response, plain_response) + post_mock.assert_awaited_once() + async def test_async_assembly_wait_raises_on_plain_text_poll_response(self): initial_response = Response( data={ @@ -439,6 +469,37 @@ async def test_async_assembly_wait_raises_on_plain_text_poll_response(self): ) sleep_mock.assert_awaited_once_with(0) + async def test_async_assembly_wait_returns_plain_text_poll_response(self): + initial_response = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + plain_response = Response( + data="plain assembly response", + status_code=200, + headers={"X-Async-Route": "plain"}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial_response)) as post_mock: + with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=plain_response)) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + response = await assembly.create(wait=True, resumable=False) + + self.assertIs(response, plain_response) + post_mock.assert_awaited_once() + get_mock.assert_awaited_once_with( + assembly_url=f"{self.server.base_url}/assemblies/assembly-123" + ) + sleep_mock.assert_awaited_once_with(0) + def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") @@ -633,7 +694,7 @@ def upload(self_inner): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() upload = io.BytesIO(b"payload") - upload.name = "payload.bin" + upload.name = b"payload.bin" assembly.add_file(upload) rate_limited = Response( @@ -730,6 +791,38 @@ def uploader(self, **kwargs): self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") + async def test_async_assembly_non_resumable_rate_limit_raises_when_stream_cannot_be_snapshotted(self): + class _NonSeekableStream(io.BytesIO): + def tell(self): + raise OSError("tell failed") + + reads = [] + + async def fake_post(path, data=None, extra_data=None, files=None): + file_stream = files["file"] + reads.append(file_stream.read()) + return Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(_NonSeekableStream(b"payload")) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(side_effect=fake_post)) as post_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + with self.assertRaises(RuntimeError): + await assembly.create(resumable=False, retries=1) + + self.assertEqual(reads, [b"payload"]) + post_mock.assert_awaited_once() + sleep_mock.assert_not_awaited() + async def test_async_assembly_resumable_rate_limit_returns_response_without_upload_when_retries_exhausted(self): calls = [] @@ -1169,9 +1262,10 @@ def test_async_assembly_helpers_cover_duplicate_names_and_rewind_edges(self): first.read(1) second.read(2) - positions = assembly._snapshot_file_positions() + positions, missing = assembly._snapshot_file_positions() self.assertEqual(positions["file"], 1) self.assertEqual(positions["file_1"], 2) + self.assertEqual(missing, []) first.read(1) second.read(1) @@ -1181,8 +1275,9 @@ def test_async_assembly_helpers_cover_duplicate_names_and_rewind_edges(self): broken = _BrokenStream() assembly.files["broken"] = broken - positions = assembly._snapshot_file_positions() + positions, missing = assembly._snapshot_file_positions() self.assertNotIn("broken", positions) + self.assertEqual(missing, ["broken"]) assembly._rewind_files({"missing": 4}) with self.assertRaises(RuntimeError): diff --git a/tests/test_response.py b/tests/test_response.py index f9cd0aa..7949919 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -1,7 +1,7 @@ import unittest from unittest import mock -from transloadit.response import Response +from transloadit.response import Response, _MISSING class ResponseTest(unittest.TestCase): @@ -21,6 +21,19 @@ def test_response_data_is_assignable_and_eager_for_sync_responses(self): self.assertEqual(response.status_code, 200) self.assertEqual(response.headers, {"X-Test": "1"}) + def test_response_lazily_rehydrates_data_when_missing(self): + raw = mock.Mock() + raw.json.return_value = {"ok": "lazy"} + raw.status_code = 204 + raw.headers = {"X-Test": "1"} + + response = Response() + response._response = raw + response._data = _MISSING + + self.assertEqual(response.data, {"ok": "lazy"}) + raw.json.assert_called_once() + def test_response_supports_async_preloaded_values_and_empty_default(self): empty = Response() self.assertIsNone(empty.data) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 2085a13..1d18781 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -43,12 +43,13 @@ def remove_file(self, field_name): def _snapshot_file_positions(self): positions = {} + missing = [] for key, file_stream in self.files.items(): try: positions[key] = file_stream.tell() except (AttributeError, OSError, ValueError): - continue - return positions + missing.append(key) + return positions, missing def _rewind_files(self, positions): for key, position in positions.items(): @@ -84,7 +85,7 @@ async def create(self, wait=False, resumable=True, retries=3): Save/Submit the assembly for processing. """ data = self.get_options() - file_positions = self._snapshot_file_positions() + file_positions, missing_file_positions = self._snapshot_file_positions() tus_retries = retries poll_retries = retries @@ -107,6 +108,12 @@ async def create(self, wait=False, resumable=True, retries=3): if self._rate_limit_reached(response_data): if retries: + if not resumable and missing_file_positions: + missing = ", ".join(repr(key) for key in missing_file_positions) + raise RuntimeError( + "Cannot retry non-resumable upload because these file streams are not seekable: " + f"{missing}" + ) await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) if not resumable: self._rewind_files(file_positions) @@ -170,4 +177,7 @@ def _assembly_finished(self, response_data): return is_aborted or is_canceled or is_completed or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) def _rate_limit_reached(self, response_data): - return response_data.get("error") == "RATE_LIMIT_REACHED" + return response_data.get("error") in { + "RATE_LIMIT_REACHED", + "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + } diff --git a/transloadit/async_request.py b/transloadit/async_request.py index e8ebc33..420e4f9 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -5,6 +5,7 @@ import hashlib import hmac import json +from types import MappingProxyType from datetime import datetime, timedelta, timezone import aiohttp @@ -17,7 +18,10 @@ def _get_upload_filename(file_stream, fallback): name = getattr(file_stream, "name", None) - if isinstance(name, (str, bytes, os.PathLike)): + if isinstance(name, (bytes, os.PathLike)): + name = os.fsdecode(name) + + if isinstance(name, str): filename = os.path.basename(name) if filename: return filename @@ -29,13 +33,13 @@ class AsyncRequest: Transloadit tailored asynchronous HTTP request object. """ - HEADERS = {"Transloadit-Client": "python-sdk:" + __version__} + HEADERS = MappingProxyType({"Transloadit-Client": "python-sdk:" + __version__}) def __init__(self, transloadit, session=None): self.transloadit = transloadit self._session = session self._owns_session = session is None - self._session_lock = asyncio.Lock() + self._session_lock = None @property def session(self): @@ -44,8 +48,16 @@ def session(self): def _headers(self): return dict(self.HEADERS) + def _get_session_lock(self): + if self._session_lock is None: + # Create the lock lazily so the client can be instantiated before the loop starts. + self._session_lock = asyncio.Lock() + return self._session_lock + async def _ensure_session(self): - async with self._session_lock: + if self._session is not None and not self._session.closed: + return self._session + async with self._get_session_lock(): if self._session is None: self._session = aiohttp.ClientSession() self._owns_session = True @@ -57,9 +69,10 @@ async def _ensure_session(self): return self._session async def aclose(self): - async with self._session_lock: + async with self._get_session_lock(): if self._session is not None and not self._session.closed and self._owns_session: await self._session.close() + self._session = None def _timeout(self, files=False): return aiohttp.ClientTimeout( From 924fffc0071c6156d95b0beb459382bbfec9438c Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 20 May 2026 22:37:05 +0200 Subject: [PATCH 12/64] Address async council review findings --- tests/test_async_client.py | 71 +++++++++++++++++++++++++++++++++++ transloadit/async_assembly.py | 5 +-- transloadit/async_request.py | 5 ++- 3 files changed, 77 insertions(+), 4 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index b369f10..f32780d 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -215,6 +215,17 @@ async def text(self): return json.dumps(self.payload) +class _UndecodableResponse: + async def json(self, **kwargs): + raise UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid start byte") + + async def text(self): + raise UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid start byte") + + async def read(self): + return b"\xff" + + class _RecordingSession: def __init__(self, payload): self.calls = [] @@ -406,6 +417,13 @@ async def test_async_client_delete_template_get_bill_and_plain_text_fallback(sel self.assertEqual(response.status_code, 200) self.assertEqual(response.headers["X-Async-Route"], "get_assembly_plain") + async def test_async_request_falls_back_to_bytes_when_text_decode_fails(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + + data = await client.request._read_response_data(_UndecodableResponse()) + + self.assertEqual(data, b"\xff") + async def test_async_assembly_create_raises_on_plain_text_error_response(self): plain_response = Response( data="plain assembly response", @@ -670,6 +688,10 @@ def __init__(self, tus_url): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") post_mock.assert_awaited_once() + self.assertEqual( + post_mock.await_args.kwargs["extra_data"], + {"tus_num_expected_upload_files": 0}, + ) get_mock.assert_awaited_once_with( assembly_url=f"{self.server.base_url}/assemblies/assembly-123" ) @@ -1040,6 +1062,55 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self): ) self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)]) + async def test_async_assembly_wait_does_not_follow_poll_response_assembly_url(self): + initial_url = f"{self.server.base_url}/assemblies/assembly-123" + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": initial_url, + }, + status_code=200, + headers={}, + ) + malicious_poll = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + "assembly_ssl_url": "https://example.invalid/assemblies/evil", + }, + status_code=200, + headers={}, + ) + completed = Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"}, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)): + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(side_effect=[malicious_poll, completed]), + ) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): + response = await assembly.create(wait=True, resumable=False, retries=2) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual( + get_mock.await_args_list, + [ + mock.call(assembly_url=initial_url), + mock.call(assembly_url=initial_url), + ], + ) + async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhausted(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 1d18781..19bfde1 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -91,7 +91,7 @@ async def create(self, wait=False, resumable=True, retries=3): while True: if resumable: - extra_data = {"tus_num_expected_upload_files": len(self.files)} if self.files else None + extra_data = {"tus_num_expected_upload_files": len(self.files)} response = await self.transloadit.request.post( "/assemblies", extra_data=extra_data, data=data ) @@ -148,14 +148,13 @@ async def create(self, wait=False, resumable=True, retries=3): sleep_time = poll_data.get("info", {}).get("retryIn", 1) await asyncio.sleep(sleep_time) poll_response = await self.transloadit.get_assembly( - assembly_url=assembly_url or poll_data.get("assembly_ssl_url") + assembly_url=assembly_url ) poll_data = self._response_data(poll_response) if poll_data is None: if poll_response.status_code >= 400: raise RuntimeError(f"Unexpected non-JSON response ({poll_response.status_code}).") return poll_response - assembly_url = poll_data.get("assembly_ssl_url") or assembly_url return poll_response diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 420e4f9..58938bc 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -96,7 +96,10 @@ async def _read_response_data(self, response): try: return await response.json(content_type=None) except (aiohttp.ContentTypeError, json.JSONDecodeError, UnicodeDecodeError): - return await response.text() + try: + return await response.text() + except UnicodeDecodeError: + return await response.read() async def get(self, path, params=None): """ From bb5852038ab3833da01eea978a091f253f701fb6 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 08:53:45 +0200 Subject: [PATCH 13/64] Add async E2E coverage --- tests/test_async_client.py | 50 ++++++++++++++++++++++--- tests/test_e2e_upload.py | 70 ++++++++++++++++++++++++++--------- tests/test_request.py | 18 +++++++++ transloadit/async_assembly.py | 2 +- transloadit/async_client.py | 10 ++++- transloadit/async_request.py | 22 ++++++----- transloadit/client.py | 10 ++++- transloadit/request.py | 6 ++- 8 files changed, 149 insertions(+), 39 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index f32780d..ade140e 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -274,6 +274,7 @@ async def test_async_client_methods_and_context_manager(self): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abc123") self.assertEqual(response.status_code, 200) + self.assertIs(type(response.headers), dict) self.assertEqual(response.headers["X-Async-Route"], "get_assembly") response = await client.list_assemblies() @@ -383,6 +384,18 @@ async def test_async_client_close_reopens_owned_session(self): await client.close() + async def test_async_request_owned_sessions_trust_environment(self): + session = _NeverOwnedSession() + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + + with mock.patch("aiohttp.ClientSession", return_value=session) as session_mock: + ensured_session = await client.request._ensure_session() + + self.assertIs(ensured_session, session) + session_mock.assert_called_once_with(trust_env=True) + + await client.close() + async def test_async_client_reopens_owned_session_when_session_is_closed(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) @@ -521,7 +534,7 @@ async def test_async_assembly_wait_returns_plain_text_poll_response(self): def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") - params = {"width": 100, "tags": ["a", "b"], "enabled": True, "skip": None} + params = {"width": 100, "tags": ["a", "b"], "enabled": True, "flags": [True, False], "skip": None} with mock.patch("time.time", return_value=1732550672.867): async_url = async_client.get_signed_smart_cdn_url( @@ -569,6 +582,9 @@ def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): self.assertIn("width=100", async_url) self.assertIn("tags=a", async_url) self.assertIn("tags=b", async_url) + self.assertIn("enabled=true", async_url) + self.assertIn("flags=true", async_url) + self.assertIn("flags=false", async_url) self.assertIn("exp=1732550672867", explicit_async_url) self.assertNotIn("width=", bare_async_url) self.assertNotIn("skip=", async_url) @@ -908,7 +924,7 @@ def uploader(self, **kwargs): post_mock.assert_awaited_once() self.assertEqual(calls, []) - async def test_async_assembly_resumable_response_without_upload_urls_skips_tus_upload(self): + async def test_async_assembly_resumable_response_without_upload_urls_raises_before_tus_upload(self): calls = [] class _TusClient: @@ -930,9 +946,9 @@ def uploader(self, **kwargs): with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock: with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - response = await assembly.create(resumable=True) + with self.assertRaises(RuntimeError): + await assembly.create(resumable=True) - self.assertIs(response, incomplete_response) post_mock.assert_awaited_once() self.assertEqual(calls, []) @@ -988,7 +1004,12 @@ def uploader(self, **kwargs): response = await assembly.create(resumable=True) self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") - self.assertEqual(to_thread_mock.await_count, 1) + tus_upload_calls = [ + call + for call in to_thread_mock.await_args_list + if getattr(call.args[0], "__name__", "") == "_do_tus_upload" + ] + self.assertEqual(len(tus_upload_calls), 1) create_request = next( entry for entry in self.server.requests if entry["path"] == "/assemblies" and entry["method"] == "POST" @@ -1232,6 +1253,25 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): self.assertIsNone(timeout.sock_read) self.assertEqual(session.calls[0][1]["data"]._fields[2][1]["Content-Type"], "image/jpeg") + async def test_async_request_payload_preserves_custom_auth_constraints(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + + payload = client.request._to_payload( + { + "auth": { + "max_size": 1024, + "referer": "https://example.com", + }, + "foo": "bar", + } + ) + + params = json.loads(payload["params"]) + self.assertEqual(params["auth"]["key"], "key") + self.assertIn("expires", params["auth"]) + self.assertEqual(params["auth"]["max_size"], 1024) + self.assertEqual(params["auth"]["referer"], "https://example.com") + async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) diff --git a/tests/test_e2e_upload.py b/tests/test_e2e_upload.py index 77042f0..361e93a 100644 --- a/tests/test_e2e_upload.py +++ b/tests/test_e2e_upload.py @@ -1,8 +1,10 @@ import os from pathlib import Path +from unittest import IsolatedAsyncioTestCase import pytest +from transloadit.async_client import AsyncTransloadit from transloadit.client import Transloadit @@ -17,38 +19,39 @@ def _is_enabled(): ] -def test_e2e_image_resize(): +def _get_e2e_credentials(): key = os.getenv("TRANSLOADIT_KEY") secret = os.getenv("TRANSLOADIT_SECRET") if not key or not secret: pytest.skip("TRANSLOADIT_KEY and TRANSLOADIT_SECRET must be set to run E2E tests") + return key, secret + + +def _get_fixture_path(): fixture_path = Path(__file__).resolve().parents[1] / "chameleon.jpg" if not fixture_path.exists(): pytest.skip("chameleon.jpg fixture missing; run from repository root") - client = Transloadit(key, secret) + return fixture_path - assembly = client.new_assembly() - with fixture_path.open("rb") as upload: - assembly.add_file(upload) - assembly.add_step( - "resize", - "/image/resize", - { - "use": ":original", - "width": 128, - "height": 128, - "resize_strategy": "fit", - "format": "png", - }, - ) +def _add_resize_step(assembly): + assembly.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 128, + "height": 128, + "resize_strategy": "fit", + "format": "png", + }, + ) - response = assembly.create(wait=True, resumable=False) - data = response.data +def _assert_e2e_image_resize(data, fixture_path): assembly_ssl_url = data.get("assembly_ssl_url") or data.get("assembly_url") assembly_id = data.get("assembly_id") print(f"[python-sdk][e2e] Assembly URL: {assembly_ssl_url} (id={assembly_id})") @@ -85,3 +88,34 @@ def test_e2e_image_resize(): f"{width}x{height}, ssl_url={ssl_url}, basename={upload_info.get('basename')}, " f"filename={upload_info.get('name')}" ) + + +def test_e2e_image_resize(): + key, secret = _get_e2e_credentials() + fixture_path = _get_fixture_path() + client = Transloadit(key, secret) + + assembly = client.new_assembly() + + with fixture_path.open("rb") as upload: + assembly.add_file(upload) + _add_resize_step(assembly) + response = assembly.create(wait=True, resumable=False) + + _assert_e2e_image_resize(response.data, fixture_path) + + +class TestAsyncE2EUpload(IsolatedAsyncioTestCase): + async def test_e2e_image_resize(self): + key, secret = _get_e2e_credentials() + fixture_path = _get_fixture_path() + + async with AsyncTransloadit(key, secret) as client: + assembly = client.new_assembly() + + with fixture_path.open("rb") as upload: + assembly.add_file(upload) + _add_resize_step(assembly) + response = await assembly.create(wait=True, resumable=False) + + _assert_e2e_image_resize(response.data, fixture_path) diff --git a/tests/test_request.py b/tests/test_request.py index 5debdb4..f4fa7fb 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -1,3 +1,4 @@ +import json import unittest import urllib.parse @@ -38,6 +39,23 @@ def test_post(self, mock): response = self.request.post("/foo", data={"foo": "bar"}) self.assertEqual(response.data["ok"], "it works") + def test_payload_preserves_custom_auth_constraints(self): + payload = self.request._to_payload( + { + "auth": { + "max_size": 1024, + "referer": "https://example.com", + }, + "foo": "bar", + } + ) + + params = json.loads(payload["params"]) + self.assertEqual(params["auth"]["key"], "key") + self.assertIn("expires", params["auth"]) + self.assertEqual(params["auth"]["max_size"], 1024) + self.assertEqual(params["auth"]["referer"], "https://example.com") + @requests_mock.Mocker() def test_put(self, mock): url = f"{self.transloadit.service}/foo" diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 19bfde1..7198c01 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -130,7 +130,7 @@ async def create(self, wait=False, resumable=True, retries=3): if resumable and self.files: if not assembly_url or not tus_url: - return response + raise RuntimeError("Resumable assembly response is missing upload URLs.") await self._do_tus_upload_async(assembly_url, tus_url, tus_retries) if wait: diff --git a/transloadit/async_client.py b/transloadit/async_client.py index be6182b..ef04d49 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -7,6 +7,12 @@ from . import async_assembly, async_request, async_template +def _stringify_url_param(value: Union[str, int, float, bool]) -> str: + if isinstance(value, bool): + return "true" if value else "false" + return str(value) + + class AsyncTransloadit: """ Asynchronous client interface to the Transloadit API. @@ -133,9 +139,9 @@ def get_signed_smart_cdn_url( if v is None: continue elif isinstance(v, (str, int, float, bool)): - params.append((k, str(v))) + params.append((k, _stringify_url_param(v))) elif isinstance(v, (list, tuple)): - params.append((k, [str(vv) for vv in v])) + params.append((k, [_stringify_url_param(vv) for vv in v])) else: raise ValueError( f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}" diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 58938bc..dba9377 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -59,11 +59,11 @@ async def _ensure_session(self): return self._session async with self._get_session_lock(): if self._session is None: - self._session = aiohttp.ClientSession() + self._session = aiohttp.ClientSession(trust_env=True) self._owns_session = True elif self._session.closed: if self._owns_session: - self._session = aiohttp.ClientSession() + self._session = aiohttp.ClientSession(trust_env=True) else: raise RuntimeError("Injected aiohttp session is closed.") return self._session @@ -75,10 +75,12 @@ async def aclose(self): self._session = None def _timeout(self, files=False): + # Large uploads can legitimately wait longer than TIMEOUT for the first response byte. + sock_read = None if files else TIMEOUT return aiohttp.ClientTimeout( total=None, sock_connect=TIMEOUT, - sock_read=None if files else TIMEOUT, + sock_read=sock_read, ) def _normalize_payload(self, data): @@ -115,7 +117,7 @@ async def get(self, path, params=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=response.headers, + headers=dict(response.headers), ) async def post(self, path, data=None, extra_data=None, files=None): @@ -149,7 +151,7 @@ async def post(self, path, data=None, extra_data=None, files=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=response.headers, + headers=dict(response.headers), ) async def put(self, path, data=None): @@ -167,7 +169,7 @@ async def put(self, path, data=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=response.headers, + headers=dict(response.headers), ) async def delete(self, path, data=None): @@ -185,16 +187,18 @@ async def delete(self, path, data=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=response.headers, + headers=dict(response.headers), ) def _to_payload(self, data): data = copy.deepcopy(data or {}) expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) - data["auth"] = { + auth = data.get("auth") if isinstance(data.get("auth"), dict) else {} + auth.update({ "key": self.transloadit.auth_key, "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"), - } + }) + data["auth"] = auth json_data = json.dumps(data) return {"params": json_data, "signature": self._sign_data(json_data)} diff --git a/transloadit/client.py b/transloadit/client.py index eeeab24..954843b 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -12,6 +12,12 @@ from requests import Response +def _stringify_url_param(value: Union[str, int, float, bool]) -> str: + if isinstance(value, bool): + return "true" if value else "false" + return str(value) + + class Transloadit: """ This class serves as a client interface to the Transloadit API. @@ -210,9 +216,9 @@ def get_signed_smart_cdn_url( if v is None: continue # Skip None values elif isinstance(v, (str, int, float, bool)): - params.append((k, str(v))) + params.append((k, _stringify_url_param(v))) elif isinstance(v, (list, tuple)): - params.append((k, [str(vv) for vv in v])) + params.append((k, [_stringify_url_param(vv) for vv in v])) else: raise ValueError(f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}") diff --git a/transloadit/request.py b/transloadit/request.py index 4cec55f..852baaf 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -114,10 +114,12 @@ def delete(self, path, data=None): def _to_payload(self, data): data = copy.deepcopy(data or {}) expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) - data["auth"] = { + auth = data.get("auth") if isinstance(data.get("auth"), dict) else {} + auth.update({ "key": self.transloadit.auth_key, "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"), - } + }) + data["auth"] = auth json_data = json.dumps(data) return {"params": json_data, "signature": self._sign_data(json_data)} From 1722c933dac7a8f935261d50509daf07ce1b7d04 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 10:03:10 +0200 Subject: [PATCH 14/64] Harden async upload edge cases --- tests/test_async_client.py | 137 ++++++++++++++++++++++++++++++++-- transloadit/async_assembly.py | 18 ++++- transloadit/async_client.py | 16 ++-- transloadit/async_request.py | 58 ++++++++++++-- transloadit/response.py | 7 +- 5 files changed, 209 insertions(+), 27 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index ade140e..c3edccc 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -1,12 +1,14 @@ -import io import asyncio +import io import json +import threading from pathlib import Path from unittest import IsolatedAsyncioTestCase, mock -from aiohttp import web +from aiohttp import payload, web from transloadit.async_client import AsyncTransloadit +from transloadit.async_request import _NonClosingUploadStream from transloadit.client import Transloadit from transloadit.response import Response @@ -232,10 +234,22 @@ def __init__(self, payload): self.closed = False self.payload = payload + def delete(self, url, **kwargs): + self.calls.append((url, kwargs)) + return _FakeResponseContext(self.payload) + + def get(self, url, **kwargs): + self.calls.append((url, kwargs)) + return _FakeResponseContext(self.payload) + def post(self, url, **kwargs): self.calls.append((url, kwargs)) return _FakeResponseContext(self.payload) + def put(self, url, **kwargs): + self.calls.append((url, kwargs)) + return _FakeResponseContext(self.payload) + async def close(self): self.closed = True @@ -274,8 +288,8 @@ async def test_async_client_methods_and_context_manager(self): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abc123") self.assertEqual(response.status_code, 200) - self.assertIs(type(response.headers), dict) self.assertEqual(response.headers["X-Async-Route"], "get_assembly") + self.assertEqual(response.headers["x-async-route"], "get_assembly") response = await client.list_assemblies() self.assertEqual(response.data["items"], []) @@ -368,6 +382,28 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): with self.assertRaises(RuntimeError): await closed_client.get_assembly(assembly_id="abc123") + async def test_async_client_quotes_path_ids(self): + session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + + await client.get_assembly(assembly_id="assembly/with?chars") + await client.cancel_assembly(assembly_id="cancel/with?chars") + await client.get_template("template/with?chars") + await client.update_template("update/with?chars", {"name": "foo"}) + await client.delete_template("delete/with?chars") + + urls = [call[0] for call in session.calls] + self.assertEqual( + urls, + [ + f"{self.server.base_url}/assemblies/assembly%2Fwith%3Fchars", + f"{self.server.base_url}/assemblies/cancel%2Fwith%3Fchars", + f"{self.server.base_url}/templates/template%2Fwith%3Fchars", + f"{self.server.base_url}/templates/update%2Fwith%3Fchars", + f"{self.server.base_url}/templates/delete%2Fwith%3Fchars", + ], + ) + async def test_async_client_close_reopens_owned_session(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) @@ -469,6 +505,34 @@ async def test_async_assembly_create_returns_plain_text_success_response(self): self.assertIs(response, plain_response) post_mock.assert_awaited_once() + async def test_async_assembly_resumable_plain_text_success_response_raises_before_tus_upload(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + raise AssertionError("TUS upload should not start without upload URLs") + + plain_response = Response( + data="plain assembly response", + status_code=200, + headers={"X-Async-Route": "plain"}, + ) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=plain_response)) as post_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + with self.assertRaises(RuntimeError): + await assembly.create(resumable=True) + + post_mock.assert_awaited_once() + self.assertEqual(calls, []) + async def test_async_assembly_wait_raises_on_plain_text_poll_response(self): initial_response = Response( data={ @@ -1182,6 +1246,7 @@ async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhaus async def test_async_assembly_non_resumable_rate_limit_rewinds_files_for_retry(self): reads = [] + upload = io.BytesIO(b"payload") async def fake_post(path, data=None, extra_data=None, files=None): file_stream = files["file"] @@ -1201,12 +1266,15 @@ async def fake_post(path, data=None, extra_data=None, files=None): headers={}, ) + async def fake_sleep(delay): + self.assertEqual(upload.tell(), 0) + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() - assembly.add_file(io.BytesIO(b"payload")) + assembly.add_file(upload) with mock.patch.object(client.request, "post", new=mock.AsyncMock(side_effect=fake_post)): - with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: + with mock.patch("asyncio.sleep", new=mock.AsyncMock(side_effect=fake_sleep)) as sleep_mock: response = await assembly.create(resumable=False, retries=2) self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") @@ -1238,6 +1306,47 @@ def seek(self, position, *args, **kwargs): post_mock.assert_awaited_once() + async def test_async_assembly_rate_limit_ignores_malformed_error_values(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + assembly = client.new_assembly() + + self.assertFalse(assembly._rate_limit_reached({"error": ["RATE_LIMIT_REACHED"]})) + self.assertFalse(assembly._rate_limit_reached({"error": {"code": "RATE_LIMIT_REACHED"}})) + + async def test_async_tus_upload_cancellation_waits_for_thread_to_finish(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + assembly = client.new_assembly() + started = threading.Event() + release = threading.Event() + finished = threading.Event() + + def blocking_upload(assembly_url, tus_url, retries): + started.set() + release.wait(timeout=5) + finished.set() + + assembly._do_tus_upload = blocking_upload + upload_task = asyncio.create_task( + assembly._do_tus_upload_async( + f"{self.server.base_url}/assemblies/assembly-123", + f"{self.server.base_url}/uploads", + retries=1, + ) + ) + + await asyncio.to_thread(started.wait, 5) + upload_task.cancel() + await asyncio.sleep(0.05) + + self.assertFalse(upload_task.done()) + self.assertFalse(finished.is_set()) + + release.set() + with self.assertRaises(asyncio.CancelledError): + await upload_task + + self.assertTrue(finished.is_set()) + async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) @@ -1250,9 +1359,25 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): timeout = session.calls[0][1]["timeout"] self.assertIsNone(timeout.total) self.assertEqual(timeout.sock_connect, 60) - self.assertIsNone(timeout.sock_read) + self.assertEqual(timeout.sock_read, 60) self.assertEqual(session.calls[0][1]["data"]._fields[2][1]["Content-Type"], "image/jpeg") + async def test_async_request_upload_does_not_close_caller_stream(self): + fixture_path = Path(__file__).resolve().parents[1] / "LICENSE" + upload = fixture_path.open("rb") + + try: + upload_payload = payload.get_payload(_NonClosingUploadStream(upload)) + await upload_payload.close() + await asyncio.sleep(0.05) + + self.assertFalse(upload.closed) + upload.seek(0) + self.assertEqual(upload.read(5), fixture_path.read_bytes()[:5]) + finally: + if not upload.closed: + upload.close() + async def test_async_request_payload_preserves_custom_auth_constraints(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 7198c01..ab97355 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -78,7 +78,16 @@ def _do_tus_upload(self, assembly_url, tus_url, retries): ).upload() async def _do_tus_upload_async(self, assembly_url, tus_url, retries): - await asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) + upload_task = asyncio.create_task( + asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) + ) + try: + await asyncio.shield(upload_task) + except asyncio.CancelledError: + try: + await asyncio.shield(upload_task) + finally: + raise async def create(self, wait=False, resumable=True, retries=3): """ @@ -104,6 +113,8 @@ async def create(self, wait=False, resumable=True, retries=3): if response_data is None: if response.status_code >= 400: raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") + if resumable and self.files: + raise RuntimeError("Resumable assembly response is missing upload URLs.") return response if self._rate_limit_reached(response_data): @@ -114,9 +125,9 @@ async def create(self, wait=False, resumable=True, retries=3): "Cannot retry non-resumable upload because these file streams are not seekable: " f"{missing}" ) - await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) if not resumable: self._rewind_files(file_positions) + await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) retries -= 1 continue return response @@ -176,7 +187,8 @@ def _assembly_finished(self, response_data): return is_aborted or is_canceled or is_completed or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) def _rate_limit_reached(self, response_data): - return response_data.get("error") in { + error = response_data.get("error") + return isinstance(error, str) and error in { "RATE_LIMIT_REACHED", "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", } diff --git a/transloadit/async_client.py b/transloadit/async_client.py index ef04d49..eaa4699 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -2,7 +2,7 @@ import hmac import time from typing import List, Optional, Union -from urllib.parse import quote_plus, urlencode +from urllib.parse import quote, quote_plus, urlencode from . import async_assembly, async_request, async_template @@ -13,6 +13,10 @@ def _stringify_url_param(value: Union[str, int, float, bool]) -> str: return str(value) +def _quote_path_segment(value: str) -> str: + return quote(str(value), safe="") + + class AsyncTransloadit: """ Asynchronous client interface to the Transloadit API. @@ -61,7 +65,7 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return await self.request.get(url) async def list_assemblies(self, params: dict = None): @@ -77,14 +81,14 @@ async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = Non if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return await self.request.delete(url) async def get_template(self, template_id: str): """ Get the template specified by the 'template_id'. """ - return await self.request.get(f"/templates/{template_id}") + return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") async def list_templates(self, params: Optional[dict] = None): """ @@ -102,13 +106,13 @@ async def update_template(self, template_id: str, data: dict): """ Update the template specified by the 'template_id'. """ - return await self.request.put(f"/templates/{template_id}", data=data) + return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) async def delete_template(self, template_id: str): """ Delete the template specified by the 'template_id'. """ - return await self.request.delete(f"/templates/{template_id}") + return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") async def get_bill(self, month: int, year: int): """ diff --git a/transloadit/async_request.py b/transloadit/async_request.py index dba9377..18f778e 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -1,4 +1,5 @@ import asyncio +import io import mimetypes import os import copy @@ -9,6 +10,7 @@ from datetime import datetime, timedelta, timezone import aiohttp +from requests.structures import CaseInsensitiveDict from . import __version__ from .response import Response @@ -28,6 +30,42 @@ def _get_upload_filename(file_stream, fallback): return fallback +class _NonClosingUploadStream(io.IOBase): + def __init__(self, file_stream): + self._file_stream = file_stream + + @property + def name(self): + return getattr(self._file_stream, "name", None) + + def close(self): + pass + + def fileno(self): + return self._file_stream.fileno() + + def read(self, *args): + return self._file_stream.read(*args) + + def readable(self): + return True + + def readline(self, *args): + return self._file_stream.readline(*args) + + def readlines(self, *args): + return self._file_stream.readlines(*args) + + def seek(self, *args): + return self._file_stream.seek(*args) + + def seekable(self): + return hasattr(self._file_stream, "seek") + + def tell(self): + return self._file_stream.tell() + + class AsyncRequest: """ Transloadit tailored asynchronous HTTP request object. @@ -75,12 +113,11 @@ async def aclose(self): self._session = None def _timeout(self, files=False): - # Large uploads can legitimately wait longer than TIMEOUT for the first response byte. - sock_read = None if files else TIMEOUT + # Keep total disabled for large request bodies, but still cap stalled responses. return aiohttp.ClientTimeout( total=None, sock_connect=TIMEOUT, - sock_read=sock_read, + sock_read=TIMEOUT, ) def _normalize_payload(self, data): @@ -117,7 +154,7 @@ async def get(self, path, params=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=dict(response.headers), + headers=CaseInsensitiveDict(response.headers), ) async def post(self, path, data=None, extra_data=None, files=None): @@ -137,7 +174,12 @@ async def post(self, path, data=None, extra_data=None, files=None): for key, file_stream in files.items(): filename = _get_upload_filename(file_stream, key) content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" - form.add_field(key, file_stream, filename=filename, content_type=content_type) + form.add_field( + key, + _NonClosingUploadStream(file_stream), + filename=filename, + content_type=content_type, + ) payload = form else: payload = self._normalize_payload(data) @@ -151,7 +193,7 @@ async def post(self, path, data=None, extra_data=None, files=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=dict(response.headers), + headers=CaseInsensitiveDict(response.headers), ) async def put(self, path, data=None): @@ -169,7 +211,7 @@ async def put(self, path, data=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=dict(response.headers), + headers=CaseInsensitiveDict(response.headers), ) async def delete(self, path, data=None): @@ -187,7 +229,7 @@ async def delete(self, path, data=None): return Response( data=await self._read_response_data(response), status_code=response.status, - headers=dict(response.headers), + headers=CaseInsensitiveDict(response.headers), ) def _to_payload(self, data): diff --git a/transloadit/response.py b/transloadit/response.py index 1abf114..7e5b289 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -9,10 +9,9 @@ class Response: Transloadit http Response Object :Attributes: - - data (dict): - Dictionary representation of the returned JSON data. For async - responses, this can also be preloaded data provided by the async - request layer. + - data (dict, str, bytes, None): + Parsed JSON data, text fallback, raw bytes for undecodable async + responses, or None when no response data is available. - status_code (int): HTTP response status code - headers (dict): From 7f8fc8cab626462b4cddede97532ade8aead7dec Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 10:20:49 +0200 Subject: [PATCH 15/64] Harden request URL and upload handling --- tests/test_async_client.py | 51 ++++++++++++++++++++++++++++++----- tests/test_client.py | 13 +++++++++ tests/test_request.py | 12 +++++++++ transloadit/async_assembly.py | 19 +++---------- transloadit/async_request.py | 49 ++++++++++++++++++++++++++------- transloadit/client.py | 16 ++++++----- transloadit/request.py | 15 +++++++++++ 7 files changed, 136 insertions(+), 39 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index c3edccc..7bfc7c6 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -365,6 +365,27 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): with self.assertRaises(ValueError): await client.cancel_assembly() + with self.assertRaises(ValueError): + await client.get_assembly(assembly_url="https://example.com/assemblies/abc123") + + with self.assertRaises(ValueError): + await client.cancel_assembly(assembly_url="https://example.com/assemblies/abc123") + + transloadit_session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + transloadit_client = AsyncTransloadit( + "key", + "secret", + service="https://api2.transloadit.com", + session=transloadit_session, + ) + await transloadit_client.get_assembly( + assembly_url="https://api2-region.transloadit.com/assemblies/abc123" + ) + self.assertEqual( + transloadit_session.calls[0][0], + "https://api2-region.transloadit.com/assemblies/abc123", + ) + await client.close() self.assertFalse(session.closed) @@ -564,7 +585,7 @@ async def test_async_assembly_wait_raises_on_plain_text_poll_response(self): ) sleep_mock.assert_awaited_once_with(0) - async def test_async_assembly_wait_returns_plain_text_poll_response(self): + async def test_async_assembly_wait_raises_on_plain_text_success_poll_response(self): initial_response = Response( data={ "ok": "ASSEMBLY_PROCESSING", @@ -586,9 +607,9 @@ async def test_async_assembly_wait_returns_plain_text_poll_response(self): with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial_response)) as post_mock: with mock.patch.object(client, "get_assembly", new=mock.AsyncMock(return_value=plain_response)) as get_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: - response = await assembly.create(wait=True, resumable=False) + with self.assertRaises(RuntimeError): + await assembly.create(wait=True, resumable=False) - self.assertIs(response, plain_response) post_mock.assert_awaited_once() get_mock.assert_awaited_once_with( assembly_url=f"{self.server.base_url}/assemblies/assembly-123" @@ -1313,7 +1334,7 @@ async def test_async_assembly_rate_limit_ignores_malformed_error_values(self): self.assertFalse(assembly._rate_limit_reached({"error": ["RATE_LIMIT_REACHED"]})) self.assertFalse(assembly._rate_limit_reached({"error": {"code": "RATE_LIMIT_REACHED"}})) - async def test_async_tus_upload_cancellation_waits_for_thread_to_finish(self): + async def test_async_tus_upload_cancellation_returns_before_thread_finishes(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) assembly = client.new_assembly() started = threading.Event() @@ -1338,13 +1359,14 @@ def blocking_upload(assembly_url, tus_url, retries): upload_task.cancel() await asyncio.sleep(0.05) - self.assertFalse(upload_task.done()) + self.assertTrue(upload_task.done()) self.assertFalse(finished.is_set()) - release.set() with self.assertRaises(asyncio.CancelledError): await upload_task + release.set() + await asyncio.to_thread(finished.wait, 5) self.assertTrue(finished.is_set()) async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self): @@ -1406,7 +1428,7 @@ async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data( response = await client.request.post( "/assemblies", data={"foo": "bar"}, - extra_data={"enabled": True, "skip": None}, + extra_data={"enabled": True, "skip": None, "tags": ["a", "b"]}, files={"file": upload}, ) @@ -1415,6 +1437,21 @@ async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data( self.assertIn("enabled", fields) self.assertNotIn("skip", fields) self.assertEqual(fields["enabled"][2], "true") + tag_values = [field[2] for field in session.calls[0][1]["data"]._fields if field[0]["name"] == "tags"] + self.assertEqual(tag_values, ["a", "b"]) + + def test_non_closing_upload_stream_reflects_seekability(self): + class _NonSeekableUpload(io.BytesIO): + def seekable(self): + return False + + class _BrokenSeekableUpload(io.BytesIO): + def seekable(self): + raise OSError("seekable failed") + + self.assertTrue(_NonClosingUploadStream(io.BytesIO(b"payload")).seekable()) + self.assertFalse(_NonClosingUploadStream(_NonSeekableUpload(b"payload")).seekable()) + self.assertFalse(_NonClosingUploadStream(_BrokenSeekableUpload(b"payload")).seekable()) async def test_async_request_uses_filename_fallback_for_trailing_slash_stream_name(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) diff --git a/tests/test_client.py b/tests/test_client.py index 584109a..156e856 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -72,6 +72,19 @@ def test_get_assembly(self, mock): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abcdef12345") + def test_quotes_path_ids(self): + with mock.patch.object(self.transloadit.request, 'get') as get_mock: + self.transloadit.get_assembly(assembly_id='assembly/with?chars') + self.transloadit.get_template('template/with?chars') + + self.assertEqual( + get_mock.call_args_list, + [ + mock.call('/assemblies/assembly%2Fwith%3Fchars'), + mock.call('/templates/template%2Fwith%3Fchars'), + ], + ) + @requests_mock.Mocker() def test_list_assemblies(self, mock): url = f"{self.transloadit.service}/assemblies" diff --git a/tests/test_request.py b/tests/test_request.py index f4fa7fb..b8bb734 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -56,6 +56,18 @@ def test_payload_preserves_custom_auth_constraints(self): self.assertEqual(params["auth"]["max_size"], 1024) self.assertEqual(params["auth"]["referer"], "https://example.com") + def test_full_url_rejects_external_absolute_urls(self): + self.assertEqual( + self.request._get_full_url(f"{self.transloadit.service}/foo"), + f"{self.transloadit.service}/foo", + ) + self.assertEqual( + self.request._get_full_url("https://api2-region.transloadit.com/foo"), + "https://api2-region.transloadit.com/foo", + ) + with self.assertRaises(ValueError): + self.request._get_full_url("https://example.com/foo") + @requests_mock.Mocker() def test_put(self, mock): url = f"{self.transloadit.service}/foo" diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index ab97355..7366af9 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -78,16 +78,7 @@ def _do_tus_upload(self, assembly_url, tus_url, retries): ).upload() async def _do_tus_upload_async(self, assembly_url, tus_url, retries): - upload_task = asyncio.create_task( - asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) - ) - try: - await asyncio.shield(upload_task) - except asyncio.CancelledError: - try: - await asyncio.shield(upload_task) - finally: - raise + await asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) async def create(self, wait=False, resumable=True, retries=3): """ @@ -111,10 +102,8 @@ async def create(self, wait=False, resumable=True, retries=3): response_data = self._response_data(response) if response_data is None: - if response.status_code >= 400: + if response.status_code >= 400 or wait or (resumable and self.files): raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") - if resumable and self.files: - raise RuntimeError("Resumable assembly response is missing upload URLs.") return response if self._rate_limit_reached(response_data): @@ -163,9 +152,7 @@ async def create(self, wait=False, resumable=True, retries=3): ) poll_data = self._response_data(poll_response) if poll_data is None: - if poll_response.status_code >= 400: - raise RuntimeError(f"Unexpected non-JSON response ({poll_response.status_code}).") - return poll_response + raise RuntimeError(f"Unexpected non-JSON response ({poll_response.status_code}).") return poll_response diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 18f778e..0a58a7c 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -8,6 +8,7 @@ import json from types import MappingProxyType from datetime import datetime, timedelta, timezone +from urllib.parse import urlparse import aiohttp from requests.structures import CaseInsensitiveDict @@ -18,6 +19,10 @@ TIMEOUT = 60 +def _is_transloadit_host(hostname): + return hostname == "transloadit.com" or hostname.endswith(".transloadit.com") + + def _get_upload_filename(file_stream, fallback): name = getattr(file_stream, "name", None) if isinstance(name, (bytes, os.PathLike)): @@ -60,6 +65,12 @@ def seek(self, *args): return self._file_stream.seek(*args) def seekable(self): + seekable = getattr(self._file_stream, "seekable", None) + if callable(seekable): + try: + return seekable() + except (OSError, ValueError): + return False return hasattr(self._file_stream, "seek") def tell(self): @@ -121,14 +132,18 @@ def _timeout(self, files=False): ) def _normalize_payload(self, data): - normalized = {} + normalized = [] for key, value in data.items(): if value is None: continue - if isinstance(value, bool): - normalized[key] = "true" if value else "false" - else: - normalized[key] = str(value) + values = value if isinstance(value, (list, tuple)) else [value] + for item in values: + if item is None: + continue + if isinstance(item, bool): + normalized.append((key, "true" if item else "false")) + else: + normalized.append((key, str(item))) return normalized async def _read_response_data(self, response): @@ -144,9 +159,10 @@ async def get(self, path, params=None): """ Makes an asynchronous HTTP GET request. """ + url = self._get_full_url(path) session = await self._ensure_session() async with session.get( - self._get_full_url(path), + url, params=self._to_payload(params), headers=self._headers(), timeout=self._timeout(), @@ -161,6 +177,7 @@ async def post(self, path, data=None, extra_data=None, files=None): """ Makes an asynchronous HTTP POST request. """ + url = self._get_full_url(path) session = await self._ensure_session() data = self._to_payload(data) if extra_data: @@ -168,7 +185,7 @@ async def post(self, path, data=None, extra_data=None, files=None): if files: form = aiohttp.FormData() - for key, value in self._normalize_payload(data).items(): + for key, value in self._normalize_payload(data): form.add_field(key, value) for key, file_stream in files.items(): @@ -185,7 +202,7 @@ async def post(self, path, data=None, extra_data=None, files=None): payload = self._normalize_payload(data) async with session.post( - self._get_full_url(path), + url, data=payload, headers=self._headers(), timeout=self._timeout(files=bool(files)), @@ -200,10 +217,11 @@ async def put(self, path, data=None): """ Makes an asynchronous HTTP PUT request. """ + url = self._get_full_url(path) session = await self._ensure_session() data = self._normalize_payload(self._to_payload(data)) async with session.put( - self._get_full_url(path), + url, data=data, headers=self._headers(), timeout=self._timeout(), @@ -218,10 +236,11 @@ async def delete(self, path, data=None): """ Makes an asynchronous HTTP DELETE request. """ + url = self._get_full_url(path) session = await self._ensure_session() data = self._normalize_payload(self._to_payload(data)) async with session.delete( - self._get_full_url(path), + url, data=data, headers=self._headers(), timeout=self._timeout(), @@ -252,5 +271,15 @@ def _sign_data(self, message): def _get_full_url(self, url): if url.startswith(("http://", "https://")): + service = urlparse(self.transloadit.service) + target = urlparse(url) + same_origin = (target.scheme, target.netloc) == (service.scheme, service.netloc) + transloadit_origin = ( + target.scheme == service.scheme + and _is_transloadit_host(service.hostname or "") + and _is_transloadit_host(target.hostname or "") + ) + if not (same_origin or transloadit_origin): + raise ValueError("Absolute API URLs must use the configured Transloadit service origin.") return url return self.transloadit.service + url diff --git a/transloadit/client.py b/transloadit/client.py index 954843b..74c9b96 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -2,7 +2,7 @@ import hmac import hashlib import time -from urllib.parse import urlencode, quote_plus +from urllib.parse import quote, quote_plus, urlencode from typing import Optional, Union, List @@ -18,6 +18,10 @@ def _stringify_url_param(value: Union[str, int, float, bool]) -> str: return str(value) +def _quote_path_segment(value: str) -> str: + return quote(str(value), safe="") + + class Transloadit: """ This class serves as a client interface to the Transloadit API. @@ -77,7 +81,7 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None): if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return self.request.get(url) def list_assemblies(self, params: dict = None): @@ -107,7 +111,7 @@ def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{assembly_id}" + url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return self.request.delete(url) def get_template(self, template_id: str): @@ -119,7 +123,7 @@ def get_template(self, template_id: str): Return an instance of """ - return self.request.get(f"/templates/{template_id}") + return self.request.get(f"/templates/{_quote_path_segment(template_id)}") def list_templates(self, params: Optional[dict] = None): """ @@ -154,7 +158,7 @@ def update_template(self, template_id: str, data: dict): Return an instance of """ - return self.request.put(f"/templates/{template_id}", data=data) + return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) def delete_template(self, template_id: str): """ @@ -165,7 +169,7 @@ def delete_template(self, template_id: str): Return an instance of """ - return self.request.delete(f"/templates/{template_id}") + return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") def get_bill(self, month: int, year: int): """ diff --git a/transloadit/request.py b/transloadit/request.py index 852baaf..f6c0758 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -3,6 +3,7 @@ import json import copy from datetime import datetime, timedelta, timezone +from urllib.parse import urlparse import requests @@ -12,6 +13,10 @@ TIMEOUT = 60 +def _is_transloadit_host(hostname): + return hostname == "transloadit.com" or hostname.endswith(".transloadit.com") + + class Request: """ Transloadit tailored HTTP Request object. @@ -131,6 +136,16 @@ def _sign_data(self, message): def _get_full_url(self, url): if url.startswith(("http://", "https://")): + service = urlparse(self.transloadit.service) + target = urlparse(url) + same_origin = (target.scheme, target.netloc) == (service.scheme, service.netloc) + transloadit_origin = ( + target.scheme == service.scheme + and _is_transloadit_host(service.hostname or "") + and _is_transloadit_host(target.hostname or "") + ) + if not (same_origin or transloadit_origin): + raise ValueError("Absolute API URLs must use the configured Transloadit service origin.") return url else: return self.transloadit.service + url From 88807ad0f9223d06fb27a6d7a9426c20a9c5d4db Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 10:52:52 +0200 Subject: [PATCH 16/64] Harden async retry and service URLs --- CHANGELOG.md | 1 + tests/test_async_client.py | 69 ++++++++++++++++++++++++++++++++--- tests/test_request.py | 8 ++-- transloadit/async_assembly.py | 21 ++++++++++- transloadit/async_request.py | 15 -------- transloadit/request.py | 16 -------- 6 files changed, 89 insertions(+), 41 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7cda431..30d05b4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ ### 2.0.0 / 2026-05-20 ### * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. +* Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Raised the runtime HTTP stack to patched versions by requiring `requests` 2.33+ and adding an explicit `urllib3` 2.7+ floor. * Updated development and documentation tooling, including `pytest` 9.0.3, `Sphinx` 9.1, `sphinx-autobuild` 2025.8, `coverage` 7.14, `tox` 4.54, and `requests-mock` 1.12. * Updated CI and local Docker test coverage to a representative Python 3.12, 3.13, and 3.14 matrix. diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 7bfc7c6..c25ab7c 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -365,11 +365,22 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): with self.assertRaises(ValueError): await client.cancel_assembly() - with self.assertRaises(ValueError): - await client.get_assembly(assembly_url="https://example.com/assemblies/abc123") - - with self.assertRaises(ValueError): - await client.cancel_assembly(assembly_url="https://example.com/assemblies/abc123") + external_session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) + external_client = AsyncTransloadit( + "key", + "secret", + service="https://api2.transloadit.com", + session=external_session, + ) + await external_client.get_assembly(assembly_url="https://example.com/assemblies/abc123") + await external_client.cancel_assembly(assembly_url="https://example.com/assemblies/abc123") + self.assertEqual( + [call[0] for call in external_session.calls], + [ + "https://example.com/assemblies/abc123", + "https://example.com/assemblies/abc123", + ], + ) transloadit_session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) transloadit_client = AsyncTransloadit( @@ -1037,6 +1048,42 @@ def uploader(self, **kwargs): post_mock.assert_awaited_once() self.assertEqual(calls, []) + async def test_async_assembly_resumable_response_allows_configured_service_tus_url(self): + calls = [] + + class _TusClient: + def __init__(self, tus_url): + calls.append(("client", tus_url)) + + def uploader(self, **kwargs): + calls.append(("upload", kwargs["metadata"])) + return self + + def upload(self): + calls.append(("uploaded",)) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + assembly.add_file(io.BytesIO(b"payload")) + + response = Response( + data={ + "assembly_ssl_url": f"{self.server.base_url}/assemblies/assembly-123", + "tus_url": "https://example.com/uploads", + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=response)) as post_mock: + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + await assembly.create(resumable=True) + + post_mock.assert_awaited_once() + self.assertEqual(calls[0], ("client", "https://example.com/uploads")) + self.assertEqual(calls[1][0], "upload") + self.assertEqual(calls[2], ("uploaded",)) + async def test_async_assembly_wait_returns_response_without_assembly_url(self): incomplete_response = Response( data={"ok": "ASSEMBLY_PROCESSING"}, @@ -1334,6 +1381,18 @@ async def test_async_assembly_rate_limit_ignores_malformed_error_values(self): self.assertFalse(assembly._rate_limit_reached({"error": ["RATE_LIMIT_REACHED"]})) self.assertFalse(assembly._rate_limit_reached({"error": {"code": "RATE_LIMIT_REACHED"}})) + async def test_async_assembly_retry_delay_sanitizes_response_info(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + assembly = client.new_assembly() + + self.assertEqual(assembly._retry_delay({}), 1) + self.assertEqual(assembly._retry_delay({"info": None}), 1) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": "bad"}}), 1) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": float("nan")}}), 1) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": -2}}), 0) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": 0.25}}), 0.25) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": 9999}}), 60) + async def test_async_tus_upload_cancellation_returns_before_thread_finishes(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) assembly = client.new_assembly() diff --git a/tests/test_request.py b/tests/test_request.py index b8bb734..a0ebf3b 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -56,7 +56,7 @@ def test_payload_preserves_custom_auth_constraints(self): self.assertEqual(params["auth"]["max_size"], 1024) self.assertEqual(params["auth"]["referer"], "https://example.com") - def test_full_url_rejects_external_absolute_urls(self): + def test_full_url_allows_explicit_absolute_urls(self): self.assertEqual( self.request._get_full_url(f"{self.transloadit.service}/foo"), f"{self.transloadit.service}/foo", @@ -65,8 +65,10 @@ def test_full_url_rejects_external_absolute_urls(self): self.request._get_full_url("https://api2-region.transloadit.com/foo"), "https://api2-region.transloadit.com/foo", ) - with self.assertRaises(ValueError): - self.request._get_full_url("https://example.com/foo") + self.assertEqual( + self.request._get_full_url("https://example.com/foo"), + "https://example.com/foo", + ) @requests_mock.Mocker() def test_put(self, mock): diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 7366af9..0b1e62b 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -1,10 +1,13 @@ import asyncio +import math from tusclient import client as tus from . import optionbuilder from .async_request import _get_upload_filename +MAX_RETRY_DELAY_SECONDS = 60 + class AsyncAssembly(optionbuilder.OptionBuilder): """ @@ -78,6 +81,8 @@ def _do_tus_upload(self, assembly_url, tus_url, retries): ).upload() async def _do_tus_upload_async(self, assembly_url, tus_url, retries): + # tuspy is synchronous: cancelling this awaiter cannot stop a worker thread already in flight. + # Returning cancellation promptly is safer than making callers wait on a stalled sync upload. await asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) async def create(self, wait=False, resumable=True, retries=3): @@ -116,7 +121,7 @@ async def create(self, wait=False, resumable=True, retries=3): ) if not resumable: self._rewind_files(file_positions) - await asyncio.sleep(response_data.get("info", {}).get("retryIn", 1)) + await asyncio.sleep(self._retry_delay(response_data)) retries -= 1 continue return response @@ -145,7 +150,7 @@ async def create(self, wait=False, resumable=True, retries=3): if remaining_rate_limit_retries <= 0: return poll_response remaining_rate_limit_retries -= 1 - sleep_time = poll_data.get("info", {}).get("retryIn", 1) + sleep_time = self._retry_delay(poll_data) await asyncio.sleep(sleep_time) poll_response = await self.transloadit.get_assembly( assembly_url=assembly_url @@ -179,3 +184,15 @@ def _rate_limit_reached(self, response_data): "RATE_LIMIT_REACHED", "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", } + + def _retry_delay(self, response_data): + info = response_data.get("info") + if not isinstance(info, dict): + return 1 + try: + delay = float(info.get("retryIn", 1)) + except (TypeError, ValueError): + return 1 + if not math.isfinite(delay): + return 1 + return min(max(delay, 0), MAX_RETRY_DELAY_SECONDS) diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 0a58a7c..4937bf5 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -8,7 +8,6 @@ import json from types import MappingProxyType from datetime import datetime, timedelta, timezone -from urllib.parse import urlparse import aiohttp from requests.structures import CaseInsensitiveDict @@ -19,10 +18,6 @@ TIMEOUT = 60 -def _is_transloadit_host(hostname): - return hostname == "transloadit.com" or hostname.endswith(".transloadit.com") - - def _get_upload_filename(file_stream, fallback): name = getattr(file_stream, "name", None) if isinstance(name, (bytes, os.PathLike)): @@ -271,15 +266,5 @@ def _sign_data(self, message): def _get_full_url(self, url): if url.startswith(("http://", "https://")): - service = urlparse(self.transloadit.service) - target = urlparse(url) - same_origin = (target.scheme, target.netloc) == (service.scheme, service.netloc) - transloadit_origin = ( - target.scheme == service.scheme - and _is_transloadit_host(service.hostname or "") - and _is_transloadit_host(target.hostname or "") - ) - if not (same_origin or transloadit_origin): - raise ValueError("Absolute API URLs must use the configured Transloadit service origin.") return url return self.transloadit.service + url diff --git a/transloadit/request.py b/transloadit/request.py index f6c0758..a17b7fc 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -3,7 +3,6 @@ import json import copy from datetime import datetime, timedelta, timezone -from urllib.parse import urlparse import requests @@ -12,11 +11,6 @@ TIMEOUT = 60 - -def _is_transloadit_host(hostname): - return hostname == "transloadit.com" or hostname.endswith(".transloadit.com") - - class Request: """ Transloadit tailored HTTP Request object. @@ -136,16 +130,6 @@ def _sign_data(self, message): def _get_full_url(self, url): if url.startswith(("http://", "https://")): - service = urlparse(self.transloadit.service) - target = urlparse(url) - same_origin = (target.scheme, target.netloc) == (service.scheme, service.netloc) - transloadit_origin = ( - target.scheme == service.scheme - and _is_transloadit_host(service.hostname or "") - and _is_transloadit_host(target.hostname or "") - ) - if not (same_origin or transloadit_origin): - raise ValueError("Absolute API URLs must use the configured Transloadit service origin.") return url else: return self.transloadit.service + url From d19832a04cd0bef60d33208143e4929194a4c71a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 13:42:43 +0200 Subject: [PATCH 17/64] Add E2E coverage for resumable uploads and templates --- .github/workflows/ci.yml | 2 +- CHANGELOG.md | 1 + tests/test_async_client.py | 2 +- tests/test_e2e_upload.py | 127 ++++++++++++++++++++++++++++++++-- tests/test_template.py | 5 +- transloadit/async_template.py | 6 +- transloadit/template.py | 6 +- 7 files changed, 140 insertions(+), 9 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e679ea5..adf4634 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -127,7 +127,7 @@ jobs: exit 1 fi - - name: Run E2E upload test + - name: Run E2E tests env: TEST_NODE_PARITY: 0 run: | diff --git a/CHANGELOG.md b/CHANGELOG.md index 30d05b4..7f584ab 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. +* Fixed sync and async template creation to send the current API `template` payload shape. * Raised the runtime HTTP stack to patched versions by requiring `requests` 2.33+ and adding an explicit `urllib3` 2.7+ floor. * Updated development and documentation tooling, including `pytest` 9.0.3, `Sphinx` 9.1, `sphinx-autobuild` 2025.8, `coverage` 7.14, `tox` 4.54, and `requests-mock` 1.12. * Updated CI and local Docker test coverage to a representative Python 3.12, 3.13, and 3.14 matrix. diff --git a/tests/test_async_client.py b/tests/test_async_client.py index c25ab7c..e2c572d 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -336,7 +336,7 @@ async def test_async_client_methods_and_context_manager(self): ) create_params = json.loads(create_request["body"]["params"]) self.assertEqual(create_params["name"], "foo") - self.assertEqual(create_params["steps"]["resize"]["robot"], "/image/resize") + self.assertEqual(create_params["template"]["steps"]["resize"]["robot"], "/image/resize") async def test_async_client_accepts_json_with_text_content_type(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: diff --git a/tests/test_e2e_upload.py b/tests/test_e2e_upload.py index 361e93a..f3c6ec7 100644 --- a/tests/test_e2e_upload.py +++ b/tests/test_e2e_upload.py @@ -1,5 +1,6 @@ import os from pathlib import Path +from uuid import uuid4 from unittest import IsolatedAsyncioTestCase import pytest @@ -37,21 +38,21 @@ def _get_fixture_path(): return fixture_path -def _add_resize_step(assembly): +def _add_resize_step(assembly, width=128, height=128): assembly.add_step( "resize", "/image/resize", { "use": ":original", - "width": 128, - "height": 128, + "width": width, + "height": height, "resize_strategy": "fit", "format": "png", }, ) -def _assert_e2e_image_resize(data, fixture_path): +def _assert_e2e_image_resize(data, fixture_path, expected_field=None, expected_fields=None): assembly_ssl_url = data.get("assembly_ssl_url") or data.get("assembly_url") assembly_id = data.get("assembly_id") print(f"[python-sdk][e2e] Assembly URL: {assembly_ssl_url} (id={assembly_id})") @@ -66,6 +67,8 @@ def _assert_e2e_image_resize(data, fixture_path): filename = upload_info.get("name") if filename: assert filename == fixture_path.name + if expected_field: + assert upload_info.get("field") == expected_field results = (data.get("results") or {}).get("resize") or [] assert results, f"Expected resize results in assembly response: {data}" @@ -83,6 +86,10 @@ def _assert_e2e_image_resize(data, fixture_path): height = int(height) assert width and height, f"Missing dimensions in result metadata: {meta}" assert 0 < width <= 128 and 0 < height <= 128 + if expected_fields: + fields = data.get("fields") or {} + for key, value in expected_fields.items(): + assert fields.get(key) == value, f"Expected field {key}={value!r}, got {fields!r}" print( "[python-sdk][e2e] Result dimensions: " f"{width}x{height}, ssl_url={ssl_url}, basename={upload_info.get('basename')}, " @@ -90,6 +97,30 @@ def _assert_e2e_image_resize(data, fixture_path): ) +def _extract_template_id(data): + template_id = data.get("id") or data.get("template_id") + assert template_id, f"Template response did not contain an id: {data}" + return template_id + + +def _extract_template_name(data): + return data.get("name") or data.get("template_name") + + +def _extract_template_content(data): + return data.get("content") or data.get("template_content") or data.get("template") + + +def _assert_template(data, expected_name, expected_width): + assert _extract_template_name(data) == expected_name, data + content = _extract_template_content(data) + assert isinstance(content, dict), data + steps = content.get("steps") or {} + resize = steps.get("resize") or {} + assert resize.get("robot") == "/image/resize", data + assert int(resize.get("width")) == expected_width, data + + def test_e2e_image_resize(): key, secret = _get_e2e_credentials() fixture_path = _get_fixture_path() @@ -105,6 +136,27 @@ def test_e2e_image_resize(): _assert_e2e_image_resize(response.data, fixture_path) +def test_e2e_resumable_image_resize(): + key, secret = _get_e2e_credentials() + fixture_path = _get_fixture_path() + expected_fields = {"python_sdk_e2e": "sync-resumable"} + client = Transloadit(key, secret) + + assembly = client.new_assembly(params={"fields": expected_fields}) + + with fixture_path.open("rb") as upload: + assembly.add_file(upload, "resumable_file") + _add_resize_step(assembly) + response = assembly.create(wait=True, resumable=True) + + _assert_e2e_image_resize( + response.data, + fixture_path, + expected_field="resumable_file", + expected_fields=expected_fields, + ) + + class TestAsyncE2EUpload(IsolatedAsyncioTestCase): async def test_e2e_image_resize(self): key, secret = _get_e2e_credentials() @@ -119,3 +171,70 @@ async def test_e2e_image_resize(self): response = await assembly.create(wait=True, resumable=False) _assert_e2e_image_resize(response.data, fixture_path) + + async def test_e2e_resumable_image_resize(self): + key, secret = _get_e2e_credentials() + fixture_path = _get_fixture_path() + expected_fields = {"python_sdk_e2e": "async-resumable"} + + async with AsyncTransloadit(key, secret) as client: + assembly = client.new_assembly(params={"fields": expected_fields}) + + with fixture_path.open("rb") as upload: + assembly.add_file(upload, "async_resumable_file") + _add_resize_step(assembly) + response = await assembly.create(wait=True, resumable=True) + + _assert_e2e_image_resize( + response.data, + fixture_path, + expected_field="async_resumable_file", + expected_fields=expected_fields, + ) + + async def test_e2e_template_lifecycle(self): + key, secret = _get_e2e_credentials() + template_name = f"python-sdk-e2e-{uuid4().hex[:12]}" + updated_name = f"{template_name}-updated" + template_id = None + deleted = False + + async with AsyncTransloadit(key, secret) as client: + try: + template = client.new_template(template_name) + _add_resize_step(template, width=64, height=64) + created = await template.create() + + template_id = _extract_template_id(created.data) + fetched = await client.get_template(template_id) + _assert_template(fetched.data, template_name, 64) + + updated = await client.update_template( + template_id, + { + "name": updated_name, + "template": { + "steps": { + "resize": { + "robot": "/image/resize", + "use": ":original", + "width": 96, + "height": 96, + "resize_strategy": "fit", + "format": "jpg", + }, + }, + }, + }, + ) + assert updated.data.get("ok") == "TEMPLATE_UPDATED", updated.data + + refetched = await client.get_template(template_id) + _assert_template(refetched.data, updated_name, 96) + + deleted_response = await client.delete_template(template_id) + assert deleted_response.data.get("ok") == "TEMPLATE_DELETED", deleted_response.data + deleted = True + finally: + if template_id and not deleted: + await client.delete_template(template_id) diff --git a/tests/test_template.py b/tests/test_template.py index 87712a5..3db4b62 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -15,7 +15,10 @@ def setUp(self): @requests_mock.Mocker() def test_save(self, mock): url = f"{self.transloadit.service}/templates" - sub_body = '"robot": "/image/resize"' + sub_body = ( + '"template": {"steps": {"resize": ' + '{"width": 70, "height": 70, "robot": "/image/resize"}}}' + ) mock.post( url, text='{"ok":"TEMPLATE_CREATED","template_name":"foo"}', diff --git a/transloadit/async_template.py b/transloadit/async_template.py index 34b2488..4925994 100644 --- a/transloadit/async_template.py +++ b/transloadit/async_template.py @@ -16,5 +16,9 @@ async def create(self): Save/Submit the template to the Transloadit server. """ data = self.get_options() - data.update({"name": self.name}) + steps = data.pop("steps") + template_content = dict(data.pop("template", {}) or {}) + if steps: + template_content["steps"] = steps + data.update({"name": self.name, "template": template_content}) return await self.transloadit.request.post("/templates", data=data) diff --git a/transloadit/template.py b/transloadit/template.py index c7254a7..90b458f 100644 --- a/transloadit/template.py +++ b/transloadit/template.py @@ -29,5 +29,9 @@ def create(self): Save/Submit the template to the Transloadit server. """ data = self.get_options() - data.update({"name": self.name}) + steps = data.pop("steps") + template_content = dict(data.pop("template", {}) or {}) + if steps: + template_content["steps"] = steps + data.update({"name": self.name, "template": template_content}) return self.transloadit.request.post("/templates", data=data) From dc77820675c35fe49ce4b5842cbac8f750937c48 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 14:14:01 +0200 Subject: [PATCH 18/64] Add runnable SDK examples --- README.md | 8 +- docs/source/index.rst | 9 +- examples/README.md | 37 ++++ examples/assembly_with_template.py | 78 ++++++++ examples/async_image_resize.py | 62 ++++++ examples/file_to_tts.py | 72 ++++--- examples/image_resize.py | 65 ++++++- examples/resumable_upload.py | 61 ++++++ examples/smart_cdn_url.py | 36 ++++ examples/template_lifecycle.py | 85 +++++++++ examples/video_translator.py | 296 +++++++++++++---------------- examples/words/text.txt | 0 tests/test_examples.py | 39 ++++ 13 files changed, 643 insertions(+), 205 deletions(-) create mode 100644 examples/README.md create mode 100644 examples/assembly_with_template.py create mode 100644 examples/async_image_resize.py create mode 100644 examples/resumable_upload.py create mode 100644 examples/smart_cdn_url.py create mode 100644 examples/template_lifecycle.py delete mode 100644 examples/words/text.txt create mode 100644 tests/test_examples.py diff --git a/README.md b/README.md index f97e803..9c9d299 100644 --- a/README.md +++ b/README.md @@ -56,9 +56,13 @@ The async client keeps polling on `asyncio.sleep`. Resumable uploads still use t If you do not use `async with`, call `await tl.aclose()` when you are done with the session. -## Example +## Examples -For fully working examples, take a look at [`examples/`](https://github.com/transloadit/python-sdk/tree/HEAD/examples). +For copy/paste runnable examples, take a look at +[`examples/`](https://github.com/transloadit/python-sdk/tree/HEAD/examples). + +The examples cover sync uploads, async uploads, resumable uploads, Template usage, +Template lifecycle management, and Smart CDN URL signing. ## Documentation diff --git a/docs/source/index.rst b/docs/source/index.rst index ac3ecd6..f917aec 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -85,9 +85,12 @@ Async usage If you do not use ``async with``, call ``await tl.aclose()`` when you are done with the session. -Example -------- +Examples +-------- + +For copy/paste runnable examples, take a look at `examples/`_. -For fully working examples, take a look at `examples/`_. +The examples cover sync uploads, async uploads, resumable uploads, Template usage, +Template lifecycle management, and Smart CDN URL signing. .. _examples/: https://github.com/transloadit/python-sdk/tree/HEAD/examples diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 0000000..b6d5b12 --- /dev/null +++ b/examples/README.md @@ -0,0 +1,37 @@ +# Transloadit Python SDK Examples + +Run the examples from the repository root after installing the project: + +```bash +poetry install +export TRANSLOADIT_KEY="YOUR_TRANSLOADIT_KEY" +export TRANSLOADIT_SECRET="YOUR_TRANSLOADIT_SECRET" +``` + +## Quickstart Examples + +```bash +poetry run python examples/image_resize.py +poetry run python examples/async_image_resize.py +poetry run python examples/resumable_upload.py +poetry run python examples/assembly_with_template.py +poetry run python examples/template_lifecycle.py +poetry run python examples/smart_cdn_url.py +``` + +`smart_cdn_url.py` only signs a URL locally. The other quickstart examples contact +Transloadit and may create temporary Assemblies or Templates in your account. + +## Advanced Examples + +These examples require pre-created Templates and, depending on your Template, third-party +provider configuration: + +```bash +export TRANSLOADIT_TTS_TEMPLATE_ID="YOUR_TEMPLATE_ID" +poetry run python examples/file_to_tts.py + +export TRANSLOADIT_TRANSCRIBE_TEMPLATE_ID="YOUR_TRANSCRIBE_TEMPLATE_ID" +export TRANSLOADIT_TRANSLATE_TEMPLATE_ID="YOUR_TRANSLATE_TEMPLATE_ID" +poetry run python examples/video_translator.py +``` diff --git a/examples/assembly_with_template.py b/examples/assembly_with_template.py new file mode 100644 index 0000000..f76f59f --- /dev/null +++ b/examples/assembly_with_template.py @@ -0,0 +1,78 @@ +"""Create a temporary Template and use it to process an uploaded image. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/assembly_with_template.py +""" + +import os +from pathlib import Path +from uuid import uuid4 + +from transloadit.client import Transloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def get_example_image_path(): + return Path(__file__).resolve().parent / "fixtures" / "lol_cat.jpg" + + +def extract_template_id(response_data): + template_id = response_data.get("id") or response_data.get("template_id") + if not template_id: + raise RuntimeError(f"Template response did not contain an id: {response_data}") + return template_id + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +def create_resize_template(client): + template = client.new_template(f"python-sdk-template-example-{uuid4().hex[:12]}") + template.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + return extract_template_id(template.create().data) + + +def main(): + key, secret = get_credentials() + client = Transloadit(key, secret) + template_id = create_resize_template(client) + + try: + assembly = client.new_assembly({"template_id": template_id}) + with get_example_image_path().open("rb") as upload: + assembly.add_file(upload, "image") + response = assembly.create(wait=True, resumable=False) + + print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Template result:", first_result_url(response.data, "resize")) + finally: + client.delete_template(template_id) + + +if __name__ == "__main__": + main() diff --git a/examples/async_image_resize.py b/examples/async_image_resize.py new file mode 100644 index 0000000..5b240e9 --- /dev/null +++ b/examples/async_image_resize.py @@ -0,0 +1,62 @@ +"""Upload and resize an image with the async client. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/async_image_resize.py +""" + +import asyncio +import os +from pathlib import Path + +from transloadit.async_client import AsyncTransloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def get_example_image_path(): + return Path(__file__).resolve().parent / "fixtures" / "lol_cat.jpg" + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +async def main(): + key, secret = get_credentials() + + async with AsyncTransloadit(key, secret) as client: + assembly = client.new_assembly() + with get_example_image_path().open("rb") as upload: + assembly.add_file(upload, "image") + assembly.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + response = await assembly.create(wait=True, resumable=False) + + print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Resized image:", first_result_url(response.data, "resize")) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/examples/file_to_tts.py b/examples/file_to_tts.py index a3b0127..bfec770 100644 --- a/examples/file_to_tts.py +++ b/examples/file_to_tts.py @@ -1,18 +1,11 @@ -### A simple Transloadit Assembly that converts a .doc file to a .txt file. It then generates a .mp3 based on the .txt file using a text-to-speech Robot. +"""Advanced example: process a document with a pre-created text-to-speech template. -''' -Template: +This requires a Template in your Transloadit account with steps similar to: { "steps": { - ":original": { - "robot": "/upload/handle" - }, - "convert": { - "use": ":original", - "robot": "/document/convert", - "format": "txt" - }, + ":original": {"robot": "/upload/handle"}, + "convert": {"use": ":original", "robot": "/document/convert", "format": "txt"}, "speech": { "use": "convert", "robot": "/text/speak", @@ -23,22 +16,51 @@ } } } -''' -from transloadit import client +Run from the repository root: -tl = client.Transloadit('TRANSLOADIT_KEY', 'TRANSLOADIT_SECRET') + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy TRANSLOADIT_TTS_TEMPLATE_ID=xxx \ + poetry run python examples/file_to_tts.py +""" -def useTemplate(templateID, file_path='', result_name='', get_url=True, fields=''): - assembly = tl.new_assembly({'template_id': templateID, 'fields': fields}) +import os +from pathlib import Path - if file_path != '': - assembly.add_file(open(file_path, 'rb')) +from transloadit.client import Transloadit - assembly_response = assembly.create(retries=5, wait=True) - if get_url: - assembly_url = assembly_response.data.get('results').get(result_name)[0].get('ssl_url') - print(assembly_url) - return assembly_url - -useTemplate ('TEMPLATE_ID', file_path='fixtures/document.doc', result_name='speech', get_url=True) \ No newline at end of file + +def get_required_env(name): + value = os.getenv(name) + if not value: + raise RuntimeError(f"Please set {name}.") + return value + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +def main(): + client = Transloadit( + get_required_env("TRANSLOADIT_KEY"), + get_required_env("TRANSLOADIT_SECRET"), + ) + template_id = get_required_env("TRANSLOADIT_TTS_TEMPLATE_ID") + document_path = Path(__file__).resolve().parent / "fixtures" / "document.doc" + + assembly = client.new_assembly({"template_id": template_id}) + with document_path.open("rb") as upload: + assembly.add_file(upload, "document") + response = assembly.create(retries=5, wait=True) + + print("Generated speech:", first_result_url(response.data, "speech")) + + +if __name__ == "__main__": + main() diff --git a/examples/image_resize.py b/examples/image_resize.py index 8fc9bcf..0bb91b0 100644 --- a/examples/image_resize.py +++ b/examples/image_resize.py @@ -1,12 +1,61 @@ -### A simple Transloadit assembly that changes the size of an image. +"""Upload an image and resize it. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/image_resize.py +""" + +import os +from pathlib import Path from transloadit.client import Transloadit -client = Transloadit("TRANSLOADIT_KEY", "TRANSLOADIT_SECRET") -assembly = client.new_assembly() -assembly.add_file(open("fixtures/lol_cat.jpg", "rb")) -assembly.add_step("resize", "/image/resize", {"width": 70, "height": 70}) -response = assembly.create(wait=True) -result_url = response.data.get("results").get("resize")[0].get("ssl_url") -print("Your result:", result_url) +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def get_example_image_path(): + return Path(__file__).resolve().parent / "fixtures" / "lol_cat.jpg" + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +def main(): + key, secret = get_credentials() + client = Transloadit(key, secret) + assembly = client.new_assembly() + + with get_example_image_path().open("rb") as upload: + assembly.add_file(upload, "image") + assembly.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + response = assembly.create(wait=True, resumable=False) + + print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Resized image:", first_result_url(response.data, "resize")) + + +if __name__ == "__main__": + main() diff --git a/examples/resumable_upload.py b/examples/resumable_upload.py new file mode 100644 index 0000000..3a3e2f5 --- /dev/null +++ b/examples/resumable_upload.py @@ -0,0 +1,61 @@ +"""Upload an image with resumable TUS upload enabled. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/resumable_upload.py +""" + +import os +from pathlib import Path + +from transloadit.client import Transloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def get_example_image_path(): + return Path(__file__).resolve().parent / "fixtures" / "lol_cat.jpg" + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +def main(): + key, secret = get_credentials() + client = Transloadit(key, secret) + assembly = client.new_assembly({"fields": {"example": "python-sdk-resumable-upload"}}) + + with get_example_image_path().open("rb") as upload: + assembly.add_file(upload, "image") + assembly.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + response = assembly.create(wait=True, resumable=True) + + print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Resumable upload result:", first_result_url(response.data, "resize")) + + +if __name__ == "__main__": + main() diff --git a/examples/smart_cdn_url.py b/examples/smart_cdn_url.py new file mode 100644 index 0000000..de2be36 --- /dev/null +++ b/examples/smart_cdn_url.py @@ -0,0 +1,36 @@ +"""Generate a signed Smart CDN URL. + +This example does not contact Transloadit. It only signs a URL locally. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/smart_cdn_url.py +""" + +import os + +from transloadit.client import Transloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def main(): + key, secret = get_credentials() + client = Transloadit(key, secret) + url = client.get_signed_smart_cdn_url( + workspace=os.getenv("TRANSLOADIT_WORKSPACE", "example-workspace"), + template=os.getenv("TRANSLOADIT_TEMPLATE", "example-template"), + input=os.getenv("TRANSLOADIT_INPUT", "image.jpg"), + url_params={"width": 320, "height": 240, "fit": "crop"}, + ) + print(url) + + +if __name__ == "__main__": + main() diff --git a/examples/template_lifecycle.py b/examples/template_lifecycle.py new file mode 100644 index 0000000..4b3b333 --- /dev/null +++ b/examples/template_lifecycle.py @@ -0,0 +1,85 @@ +"""Create, fetch, update, and delete a Template. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/template_lifecycle.py +""" + +import os +from uuid import uuid4 + +from transloadit.client import Transloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def extract_template_id(response_data): + template_id = response_data.get("id") or response_data.get("template_id") + if not template_id: + raise RuntimeError(f"Template response did not contain an id: {response_data}") + return template_id + + +def main(): + key, secret = get_credentials() + client = Transloadit(key, secret) + template_id = None + deleted = False + template_name = f"python-sdk-example-{uuid4().hex[:12]}" + + try: + template = client.new_template(template_name) + template.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + created = template.create() + template_id = extract_template_id(created.data) + print("Created template:", template_id) + + fetched = client.get_template(template_id) + print("Fetched template:", fetched.data.get("name") or fetched.data.get("template_name")) + + updated = client.update_template( + template_id, + { + "name": f"{template_name}-updated", + "template": { + "steps": { + "resize": { + "use": ":original", + "robot": "/image/resize", + "width": 96, + "height": 96, + "resize_strategy": "fit", + "format": "jpg", + }, + }, + }, + }, + ) + print("Updated template:", updated.data.get("ok")) + + deleted_response = client.delete_template(template_id) + print("Deleted template:", deleted_response.data.get("ok")) + deleted = True + finally: + if template_id and not deleted: + client.delete_template(template_id) + + +if __name__ == "__main__": + main() diff --git a/examples/video_translator.py b/examples/video_translator.py index 02e9ff3..22b5ddb 100644 --- a/examples/video_translator.py +++ b/examples/video_translator.py @@ -1,168 +1,130 @@ -### A Transloadit Assembly that adds a translated TTS-voice (english to dutch) to an input video of hermit crabs. - -''' -Template 1: - -{ - "steps": { - "transcribe_json": { - "use": ":original", - "robot": "/speech/transcribe", - "provider": "aws", - "source_language": "${fields.language}", - "format": "json", - "result": true - } - } -} -''' - -''' -Template 2: - -{ - "steps": { - ":original": { - "robot": "/upload/handle" - }, - "import_video": { - "robot": "/http/import", - "url": "${fields.video}" - }, - "translate": { - "use": ":original", - "robot": "/text/translate", - "provider": "gcp", - "target_language": "${fields.target_language}", - "source_language": "${fields.source_language}", - "result": true - }, - "speech": { - "use": "translate", - "robot": "/text/speak", - "provider": "gcp", - "target_language": "${fields.target_language}", - "voice": "female-1", - "ssml": true, - "result": true - }, - "extract_audio": { - "use": "import_video", - "robot": "/video/encode", - "result": true, - "preset": "mp3", - "ffmpeg": { - "af": "${fields.ffmpeg}" - }, - "ffmpeg_stack": "v3.3.3" - }, - "merged_audio": { - "robot": "/audio/merge", - "preset": "mp3", - "result": "true", - "ffmpeg_stack": "v4.3.1", - "use": { - "steps": [ - { - "name": "extract_audio", - "as": "audio" - }, - { - "name": "speech", - "as": "audio" - } - ], - "volume": "sum", - "bundle_steps": true - } - }, - "merged_video": { - "robot": "/video/merge", - "preset": "hls-720p", - "ffmpeg_stack": "v4.3.1", - "use": { - "steps": [ - { - "name": "merged_audio", - "as": "audio" - }, - { - "name": "import_video", - "as": "video" - } - ], - "bundle_steps": true - } - } - } -} -''' - -from transloadit import client -import urllib.request -import json +"""Advanced example: translate speech and merge translated audio into a video. + +This requires two pre-created Templates in your Transloadit account: + +1. A transcription Template that produces a `transcribe_json` result. +2. A video merge Template that accepts `video`, `target_language`, `source_language`, and + `ffmpeg` fields and produces a `merged_video` result. -tl = client.Transloadit('TRANSLOADIT_KEY', 'TRANSLOADIT_SECRET') - -source_language = 'en-GB' -target_language = 'nl-NL' - -def useTemplate(templateID, file_path='', result_name='', get_url=True, fields=''): - assembly = tl.new_assembly({'template_id': templateID, 'fields': fields}) - - if file_path != '': - assembly.add_file(open(file_path, 'rb')) - - assembly_response = assembly.create(retries=5, wait=True) - if get_url: - result_url = assembly_response.data.get('results').get(result_name)[0].get('ssl_url') - print(result_url) - return result_url - else: - return assembly_response - -response = useTemplate ('TEMPLATE_1_ID', file_path='medium_crab.mp4', get_url=False, fields={"language":source_language}) -transcription_result_url = response.data.get('results').get('transcribe_json')[0].get('ssl_url') -video_url = response.data.get('uploads')[0].get('ssl_url') - -urllib.request.urlretrieve(transcription_result_url, 'transcribe_json') - -with open('transcribe_json') as f: - data = json.load(f) - -ffmpeg = "volume=enable:volume=1" - -startTimes = [] -endTimes = [] -sentences = [] -currentSentence = '' - -startTimes.append(data['words'][0]['startTime']) - -for x in range(len(data['words'])): - if (data['words'][x]['text'] == '.') and (x != len(data['words']) - 1): - time = data['words'][x+1]['startTime'] - startTimes.append(time) - if (data['words'][x]['text'] != '.'): - currentSentence = currentSentence + ' ' + data['words'][x]['text'] - else: - sentences.append(currentSentence + '.') - time = data['words'][x-1]['endTime'] - endTimes.append(time) - currentSentence = '' - -print('startTimes: ' + str(startTimes)) -print('endTimes: ' + str(startTimes)) -print(sentences) - -f = open("words/text.txt", "w") -f.write("") - -for x in range(len(sentences)): - f.write('{text}'.format(start=startTimes[x], text=sentences[x])) - ffmpeg += ", volume=enable='between(t,{start},{end})':volume=0.2".format(start=startTimes[x], end=endTimes[x]) - -f.write("") -f.close() - -final_result_url = useTemplate ('TEMPLATE_2_ID', file_path='words/text.txt', result_name='merged_video', get_url=True, fields={"target_language":target_language, "source_language":source_language, "video":video_url, "ffmpeg":ffmpeg}) \ No newline at end of file +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy \ + TRANSLOADIT_TRANSCRIBE_TEMPLATE_ID=xxx TRANSLOADIT_TRANSLATE_TEMPLATE_ID=yyy \ + poetry run python examples/video_translator.py +""" + +import json +import os +import tempfile +import urllib.request +from pathlib import Path + +from transloadit.client import Transloadit + + +def get_required_env(name): + value = os.getenv(name) + if not value: + raise RuntimeError(f"Please set {name}.") + return value + + +def first_result_url(response_data, step_name): + results = (response_data.get("results") or {}).get(step_name) or [] + if not results: + raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") + url = results[0].get("ssl_url") or results[0].get("url") + if not url: + raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") + return url + + +def create_assembly_with_template(client, template_id, file_path=None, fields=None): + assembly = client.new_assembly({"template_id": template_id, "fields": fields or {}}) + + if file_path is None: + return assembly.create(retries=5, wait=True) + + with Path(file_path).open("rb") as upload: + assembly.add_file(upload, Path(file_path).name) + return assembly.create(retries=5, wait=True) + + +def build_ssml_and_ffmpeg(words): + if not words: + raise RuntimeError("Transcription result did not contain any words.") + + sentences = [] + start_times = [] + end_times = [] + current_sentence = [] + + start_times.append(words[0]["startTime"]) + for index, word in enumerate(words): + if word["text"] == "." and index != len(words) - 1: + start_times.append(words[index + 1]["startTime"]) + if word["text"] != ".": + current_sentence.append(word["text"]) + continue + sentences.append(" ".join(current_sentence) + ".") + end_times.append(words[index - 1]["endTime"]) + current_sentence = [] + + ffmpeg = "volume=enable:volume=1" + ssml_parts = [""] + for index, sentence in enumerate(sentences): + ssml_parts.append(f'{sentence}') + ffmpeg += ( + f", volume=enable='between(t,{start_times[index]},{end_times[index]})':volume=0.2" + ) + ssml_parts.append("") + return "".join(ssml_parts), ffmpeg + + +def main(): + client = Transloadit( + get_required_env("TRANSLOADIT_KEY"), + get_required_env("TRANSLOADIT_SECRET"), + ) + transcribe_template_id = get_required_env("TRANSLOADIT_TRANSCRIBE_TEMPLATE_ID") + translate_template_id = get_required_env("TRANSLOADIT_TRANSLATE_TEMPLATE_ID") + source_language = os.getenv("TRANSLOADIT_SOURCE_LANGUAGE", "en-GB") + target_language = os.getenv("TRANSLOADIT_TARGET_LANGUAGE", "nl-NL") + example_dir = Path(__file__).resolve().parent + + transcribe_response = create_assembly_with_template( + client, + transcribe_template_id, + file_path=example_dir / "fixtures" / "crab.mp4", + fields={"language": source_language}, + ) + transcription_url = first_result_url(transcribe_response.data, "transcribe_json") + video_url = transcribe_response.data["uploads"][0]["ssl_url"] + + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir_path = Path(tmpdir) + transcript_path = tmpdir_path / "transcribe_json.json" + urllib.request.urlretrieve(transcription_url, transcript_path) + with transcript_path.open() as transcript: + transcript_data = json.load(transcript) + + ssml, ffmpeg = build_ssml_and_ffmpeg(transcript_data["words"]) + text_path = tmpdir_path / "text.txt" + text_path.write_text(ssml) + + translated_response = create_assembly_with_template( + client, + translate_template_id, + file_path=text_path, + fields={ + "target_language": target_language, + "source_language": source_language, + "video": video_url, + "ffmpeg": ffmpeg, + }, + ) + print("Translated video:", first_result_url(translated_response.data, "merged_video")) + + +if __name__ == "__main__": + main() diff --git a/examples/words/text.txt b/examples/words/text.txt deleted file mode 100644 index e69de29..0000000 diff --git a/tests/test_examples.py b/tests/test_examples.py new file mode 100644 index 0000000..9ce0dfe --- /dev/null +++ b/tests/test_examples.py @@ -0,0 +1,39 @@ +import os +import runpy +import subprocess +import sys +from pathlib import Path + + +REPO_ROOT = Path(__file__).resolve().parents[1] +EXAMPLES_ROOT = REPO_ROOT / "examples" + + +def test_examples_import_without_side_effects(): + for example_path in sorted(EXAMPLES_ROOT.glob("*.py")): + if example_path.name == "__init__.py": + continue + runpy.run_path(str(example_path), run_name="__example_import__") + + +def test_smart_cdn_example_runs_without_network(): + env = { + **os.environ, + "PYTHONPATH": str(REPO_ROOT), + "TRANSLOADIT_KEY": "test-key", + "TRANSLOADIT_SECRET": "test-secret", + "TRANSLOADIT_WORKSPACE": "workspace", + "TRANSLOADIT_TEMPLATE": "template", + "TRANSLOADIT_INPUT": "image.jpg", + } + result = subprocess.run( + [sys.executable, "examples/smart_cdn_url.py"], + cwd=REPO_ROOT, + env=env, + text=True, + capture_output=True, + check=True, + ) + + assert result.stdout.startswith("https://workspace.tlcdn.com/template/image.jpg?") + assert "sig=sha256%3A" in result.stdout From 51fdac5e2ffc3df3474e067d3956a2fbccbc0ba4 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 14:26:04 +0200 Subject: [PATCH 19/64] Run quickstart examples in CI --- .github/workflows/ci.yml | 4 ++-- README.md | 6 ++--- examples/README.md | 3 +++ tests/test_examples.py | 47 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 55 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index adf4634..ef00fd2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -127,8 +127,8 @@ jobs: exit 1 fi - - name: Run E2E tests + - name: Run E2E tests and examples env: TEST_NODE_PARITY: 0 run: | - poetry run pytest tests/test_e2e_upload.py -q --maxfail=1 --no-cov + poetry run pytest tests/test_e2e_upload.py tests/test_examples.py -q --maxfail=1 --no-cov diff --git a/README.md b/README.md index 9c9d299..06cb90b 100644 --- a/README.md +++ b/README.md @@ -84,17 +84,17 @@ This script will: - install Poetry, Node.js 24, and the Transloadit CLI - pass credentials from `.env` (if present) so end-to-end tests can run against real Transloadit accounts -Signature parity tests use `npx transloadit smart_sig` under the hood, matching the reference implementation used by our other SDKs. Our GitHub Actions workflow also runs the E2E upload against Python 3.14 on every push/PR using a dedicated Transloadit test account (wired through the `TRANSLOADIT_KEY` and `TRANSLOADIT_SECRET` secrets). +Signature parity tests use `npx transloadit smart_sig` under the hood, matching the reference implementation used by our other SDKs. Our GitHub Actions workflow also runs the E2E upload and quickstart examples against Python 3.14 on every push/PR using a dedicated Transloadit test account (wired through the `TRANSLOADIT_KEY` and `TRANSLOADIT_SECRET` secrets). Pass `--python 3.14` (or set `PYTHON_VERSIONS`) to restrict the matrix, or append a custom command after `--`, for example `scripts/test-in-docker.sh -- pytest -k smartcdn`. To exercise the optional end-to-end upload against a real Transloadit account, provide `TRANSLOADIT_KEY` and `TRANSLOADIT_SECRET` (via environment variables or `.env`) and set `PYTHON_SDK_E2E=1`: ```bash -PYTHON_SDK_E2E=1 scripts/test-in-docker.sh --python 3.14 -- pytest tests/test_e2e_upload.py +PYTHON_SDK_E2E=1 scripts/test-in-docker.sh --python 3.14 -- pytest tests/test_e2e_upload.py tests/test_examples.py ``` -The test uploads `chameleon.jpg`, resizes it, and asserts on the live assembly results. +The tests upload `chameleon.jpg`, run the copy/paste quickstart examples, and assert on the live assembly results. If you have a global installation of `poetry`, you can run the tests with: diff --git a/examples/README.md b/examples/README.md index b6d5b12..3ab5398 100644 --- a/examples/README.md +++ b/examples/README.md @@ -22,6 +22,9 @@ poetry run python examples/smart_cdn_url.py `smart_cdn_url.py` only signs a URL locally. The other quickstart examples contact Transloadit and may create temporary Assemblies or Templates in your account. +These quickstart examples run in CI against a dedicated Transloadit test account, so they +are kept in sync with the SDK and API. + ## Advanced Examples These examples require pre-created Templates and, depending on your Template, third-party diff --git a/tests/test_examples.py b/tests/test_examples.py index 9ce0dfe..0c384ef 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -4,9 +4,28 @@ import sys from pathlib import Path +import pytest + REPO_ROOT = Path(__file__).resolve().parents[1] EXAMPLES_ROOT = REPO_ROOT / "examples" +QUICKSTART_EXAMPLES = [ + "image_resize.py", + "async_image_resize.py", + "resumable_upload.py", + "assembly_with_template.py", + "template_lifecycle.py", + "smart_cdn_url.py", +] + + +def _is_e2e_enabled(): + flag = os.getenv("PYTHON_SDK_E2E", "") + return flag.lower() in {"1", "true", "yes", "on"} + + +def _has_credentials(): + return bool(os.getenv("TRANSLOADIT_KEY") and os.getenv("TRANSLOADIT_SECRET")) def test_examples_import_without_side_effects(): @@ -37,3 +56,31 @@ def test_smart_cdn_example_runs_without_network(): assert result.stdout.startswith("https://workspace.tlcdn.com/template/image.jpg?") assert "sig=sha256%3A" in result.stdout + + +@pytest.mark.e2e +@pytest.mark.skipif(not _is_e2e_enabled(), reason="Set PYTHON_SDK_E2E=1 to run live examples") +@pytest.mark.skipif( + not _has_credentials(), + reason="TRANSLOADIT_KEY and TRANSLOADIT_SECRET must be set to run live examples", +) +@pytest.mark.parametrize("example_name", QUICKSTART_EXAMPLES) +def test_quickstart_example_runs_against_transloadit(example_name): + env = { + **os.environ, + "PYTHONPATH": str(REPO_ROOT), + } + result = subprocess.run( + [sys.executable, f"examples/{example_name}"], + cwd=REPO_ROOT, + env=env, + text=True, + capture_output=True, + ) + + assert result.returncode == 0, ( + f"{example_name} failed with exit code {result.returncode}\n" + f"STDOUT:\n{result.stdout}\n" + f"STDERR:\n{result.stderr}" + ) + assert result.stdout.strip(), f"{example_name} completed without printing output" From 86afdccbbed1de94f61504e694556b44b6c7ba2f Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 14:38:42 +0200 Subject: [PATCH 20/64] Add async template lifecycle example --- README.md | 2 +- docs/source/index.rst | 2 +- examples/README.md | 1 + examples/async_template_lifecycle.py | 86 ++++++++++++++++++++++++++++ tests/test_examples.py | 1 + 5 files changed, 90 insertions(+), 2 deletions(-) create mode 100644 examples/async_template_lifecycle.py diff --git a/README.md b/README.md index 06cb90b..74e6b4a 100644 --- a/README.md +++ b/README.md @@ -62,7 +62,7 @@ For copy/paste runnable examples, take a look at [`examples/`](https://github.com/transloadit/python-sdk/tree/HEAD/examples). The examples cover sync uploads, async uploads, resumable uploads, Template usage, -Template lifecycle management, and Smart CDN URL signing. +sync and async Template lifecycle management, and Smart CDN URL signing. ## Documentation diff --git a/docs/source/index.rst b/docs/source/index.rst index f917aec..9d987b4 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -91,6 +91,6 @@ Examples For copy/paste runnable examples, take a look at `examples/`_. The examples cover sync uploads, async uploads, resumable uploads, Template usage, -Template lifecycle management, and Smart CDN URL signing. +sync and async Template lifecycle management, and Smart CDN URL signing. .. _examples/: https://github.com/transloadit/python-sdk/tree/HEAD/examples diff --git a/examples/README.md b/examples/README.md index 3ab5398..4253a14 100644 --- a/examples/README.md +++ b/examples/README.md @@ -16,6 +16,7 @@ poetry run python examples/async_image_resize.py poetry run python examples/resumable_upload.py poetry run python examples/assembly_with_template.py poetry run python examples/template_lifecycle.py +poetry run python examples/async_template_lifecycle.py poetry run python examples/smart_cdn_url.py ``` diff --git a/examples/async_template_lifecycle.py b/examples/async_template_lifecycle.py new file mode 100644 index 0000000..db4f4e8 --- /dev/null +++ b/examples/async_template_lifecycle.py @@ -0,0 +1,86 @@ +"""Create, fetch, update, and delete a Template with the async client. + +Run from the repository root: + + TRANSLOADIT_KEY=xxx TRANSLOADIT_SECRET=yyy poetry run python examples/async_template_lifecycle.py +""" + +import asyncio +import os +from uuid import uuid4 + +from transloadit.async_client import AsyncTransloadit + + +def get_credentials(): + key = os.getenv("TRANSLOADIT_KEY") + secret = os.getenv("TRANSLOADIT_SECRET") + if not key or not secret: + raise RuntimeError("Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET.") + return key, secret + + +def extract_template_id(response_data): + template_id = response_data.get("id") or response_data.get("template_id") + if not template_id: + raise RuntimeError(f"Template response did not contain an id: {response_data}") + return template_id + + +async def main(): + key, secret = get_credentials() + template_id = None + deleted = False + template_name = f"python-sdk-async-example-{uuid4().hex[:12]}" + + async with AsyncTransloadit(key, secret) as client: + try: + template = client.new_template(template_name) + template.add_step( + "resize", + "/image/resize", + { + "use": ":original", + "width": 120, + "height": 120, + "resize_strategy": "fit", + "format": "png", + }, + ) + created = await template.create() + template_id = extract_template_id(created.data) + print("Created template:", template_id) + + fetched = await client.get_template(template_id) + print("Fetched template:", fetched.data.get("name") or fetched.data.get("template_name")) + + updated = await client.update_template( + template_id, + { + "name": f"{template_name}-updated", + "template": { + "steps": { + "resize": { + "use": ":original", + "robot": "/image/resize", + "width": 96, + "height": 96, + "resize_strategy": "fit", + "format": "jpg", + }, + }, + }, + }, + ) + print("Updated template:", updated.data.get("ok")) + + deleted_response = await client.delete_template(template_id) + print("Deleted template:", deleted_response.data.get("ok")) + deleted = True + finally: + if template_id and not deleted: + await client.delete_template(template_id) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/tests/test_examples.py b/tests/test_examples.py index 0c384ef..b2cdc6a 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -15,6 +15,7 @@ "resumable_upload.py", "assembly_with_template.py", "template_lifecycle.py", + "async_template_lifecycle.py", "smart_cdn_url.py", ] From 017fefcbb39fc9d5ae15943e26ce1dd9286fb508 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 15:54:24 +0200 Subject: [PATCH 21/64] Fix council review edge cases --- CHANGELOG.md | 1 + examples/video_translator.py | 7 +- tests/test_assembly.py | 67 ++++++++++++++++++ tests/test_async_client.py | 130 ++++++++++++++++++++++++++++++---- tests/test_client.py | 38 ++++++++++ tests/test_examples.py | 30 ++++++++ tests/test_request.py | 15 ++++ tests/test_response.py | 12 ++++ transloadit/api_url.py | 47 ++++++++++++ transloadit/assembly.py | 36 ++++++---- transloadit/async_assembly.py | 38 +++++++--- transloadit/async_client.py | 69 +++++------------- transloadit/async_request.py | 58 +++++++-------- transloadit/client.py | 72 +++++-------------- transloadit/request.py | 37 +++++++--- transloadit/response.py | 13 +++- transloadit/smart_cdn.py | 89 +++++++++++++++++++++++ transloadit/upload.py | 13 ++++ 18 files changed, 589 insertions(+), 183 deletions(-) create mode 100644 transloadit/api_url.py create mode 100644 transloadit/smart_cdn.py create mode 100644 transloadit/upload.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 7f584ab..2700f05 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ ### 2.0.0 / 2026-05-20 ### * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. +* Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async polling rate-limit retries reset after successful polls, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. * Raised the runtime HTTP stack to patched versions by requiring `requests` 2.33+ and adding an explicit `urllib3` 2.7+ floor. diff --git a/examples/video_translator.py b/examples/video_translator.py index 22b5ddb..a016b3e 100644 --- a/examples/video_translator.py +++ b/examples/video_translator.py @@ -50,6 +50,11 @@ def create_assembly_with_template(client, template_id, file_path=None, fields=No return assembly.create(retries=5, wait=True) +def download_url(url, path, timeout=60): + with urllib.request.urlopen(url, timeout=timeout) as response: + Path(path).write_bytes(response.read()) + + def build_ssml_and_ffmpeg(words): if not words: raise RuntimeError("Transcription result did not contain any words.") @@ -104,7 +109,7 @@ def main(): with tempfile.TemporaryDirectory() as tmpdir: tmpdir_path = Path(tmpdir) transcript_path = tmpdir_path / "transcribe_json.json" - urllib.request.urlretrieve(transcription_url, transcript_path) + download_url(transcription_url, transcript_path) with transcript_path.open() as transcript: transcript_data = json.load(transcript) diff --git a/tests/test_assembly.py b/tests/test_assembly.py index 6dc3fe4..0a034ae 100644 --- a/tests/test_assembly.py +++ b/tests/test_assembly.py @@ -1,9 +1,12 @@ +import io import unittest +from unittest import mock import requests_mock from . import request_body_matcher from transloadit.client import Transloadit +from transloadit.response import Response class AssemblyTest(unittest.TestCase): @@ -63,3 +66,67 @@ def test_save_resumable(self, mock): assembly = self.assembly.create() self.assertEqual(assembly.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(assembly.data["assembly_id"], "abcdef45673") + + @requests_mock.Mocker() + def test_save_resumable_uses_field_name_for_nameless_stream(self, mock_requests): + url = f"{self.transloadit.service}/assemblies" + mock_requests.post( + url, + text=( + '{"ok":"ASSEMBLY_UPLOADING",' + '"assembly_ssl_url":"https://api2.example/assemblies/abc",' + '"tus_url":"https://api2.example/uploads"}' + ), + ) + upload = io.BytesIO(b"payload") + self.assembly.add_file(upload, "payload_field") + + with mock.patch("transloadit.assembly.tus.TusClient") as tus_client: + uploader = tus_client.return_value.uploader.return_value + assembly = self.assembly.create(resumable=True) + + self.assertEqual(assembly.data["ok"], "ASSEMBLY_UPLOADING") + tus_client.return_value.uploader.assert_called_once() + self.assertEqual( + tus_client.return_value.uploader.call_args.kwargs["metadata"]["filename"], + "payload_field", + ) + uploader.upload.assert_called_once() + + def test_save_resumable_retries_rate_limit_before_tus_upload(self): + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + success = Response( + data={ + "ok": "ASSEMBLY_UPLOADING", + "assembly_ssl_url": "https://api2.example/assemblies/abc", + "tus_url": "https://api2.example/uploads", + }, + status_code=200, + headers={}, + ) + self.assembly.add_file(io.BytesIO(b"payload"), "payload_field") + + with mock.patch.object( + self.transloadit.request, + "post", + side_effect=[rate_limited, success], + ) as post_mock: + with mock.patch("transloadit.assembly.tus.TusClient") as tus_client: + uploader = tus_client.return_value.uploader.return_value + assembly = self.assembly.create(resumable=True, retries=1) + + self.assertEqual(assembly.data["ok"], "ASSEMBLY_UPLOADING") + self.assertEqual(post_mock.call_count, 2) + tus_client.assert_called_once_with("https://api2.example/uploads") + self.assertEqual( + tus_client.return_value.uploader.call_args.kwargs["metadata"]["assembly_url"], + "https://api2.example/assemblies/abc", + ) + uploader.upload.assert_called_once() diff --git a/tests/test_async_client.py b/tests/test_async_client.py index e2c572d..bc12310 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -359,6 +359,10 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): self.assertEqual(client.service, "https://api2.transloadit.com") + for service in ("", " ", "https://", "ftp://api2.transloadit.com"): + with self.assertRaises(ValueError): + AsyncTransloadit("key", "secret", service=service, session=session) + with self.assertRaises(ValueError): await client.get_assembly() @@ -381,6 +385,8 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): "https://example.com/assemblies/abc123", ], ) + self.assertIsNone(external_session.calls[0][1]["params"]) + self.assertEqual(external_session.calls[1][1]["data"], []) transloadit_session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) transloadit_client = AsyncTransloadit( @@ -396,6 +402,7 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): transloadit_session.calls[0][0], "https://api2-region.transloadit.com/assemblies/abc123", ) + self.assertIn("signature", transloadit_session.calls[0][1]["params"]) await client.close() @@ -436,6 +443,20 @@ async def test_async_client_quotes_path_ids(self): ], ) + async def test_async_client_rejects_empty_template_ids(self): + session = _RecordingSession({"ok": "TEMPLATE_FOUND"}) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + + for template_id in ("", None): + with self.assertRaises(ValueError): + await client.get_template(template_id) + with self.assertRaises(ValueError): + await client.update_template(template_id, {"name": "foo"}) + with self.assertRaises(ValueError): + await client.delete_template(template_id) + + self.assertEqual(session.calls, []) + async def test_async_client_close_reopens_owned_session(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) @@ -634,38 +655,38 @@ def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): with mock.patch("time.time", return_value=1732550672.867): async_url = async_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", params, ) explicit_async_url = async_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", params, expires_at_ms=1732550672867, ) sync_url = sync_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", params, ) explicit_sync_url = sync_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", params, expires_at_ms=1732550672867, ) bare_async_url = async_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", ) bare_sync_url = sync_client.get_signed_smart_cdn_url( - "Acme Workspace", + "acme-workspace", "My Template", "folder/file name.jpg", ) @@ -687,6 +708,18 @@ def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): with self.assertRaises(ValueError): async_client.get_signed_smart_cdn_url("workspace", "template", "input", {"bad": object()}) + with self.assertRaises(ValueError): + async_client.get_signed_smart_cdn_url("Acme Workspace", "template", "input") + with self.assertRaises(ValueError): + sync_client.get_signed_smart_cdn_url("bad.workspace", "template", "input") + for reserved_key in ("auth_key", "exp", "sig"): + with self.assertRaises(ValueError): + async_client.get_signed_smart_cdn_url( + "workspace", + "template", + "input", + {reserved_key: "override"}, + ) async def test_async_assembly_create_non_resumable_upload(self): fixture_path = Path(__file__).resolve().parents[1] / "LICENSE" @@ -1042,7 +1075,7 @@ def uploader(self, **kwargs): with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock: with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - with self.assertRaises(RuntimeError): + with self.assertRaisesRegex(RuntimeError, "ASSEMBLY_PROCESSING"): await assembly.create(resumable=True) post_mock.assert_awaited_once() @@ -1215,6 +1248,69 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self): ) self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)]) + async def test_async_assembly_wait_resets_poll_rate_limit_retry_budget(self): + assembly_url = f"{self.server.base_url}/assemblies/assembly-123" + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + assembly = client.new_assembly() + + initial = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": assembly_url, + }, + status_code=200, + headers={"X-Async-Route": "initial"}, + ) + rate_limited = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + "assembly_ssl_url": assembly_url, + }, + status_code=200, + headers={"X-Async-Route": "rate_limited"}, + ) + processing = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": assembly_url, + }, + status_code=200, + headers={"X-Async-Route": "processing"}, + ) + completed = Response( + data={ + "ok": "ASSEMBLY_COMPLETED", + "assembly_id": "assembly-123", + "assembly_ssl_url": assembly_url, + }, + status_code=200, + headers={"X-Async-Route": "completed"}, + ) + + with mock.patch.object( + client.request, + "post", + new=mock.AsyncMock(return_value=initial), + ) as post_mock: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock( + side_effect=[rate_limited, processing, rate_limited, completed] + ), + ) as get_mock: + with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): + response = await assembly.create(wait=True, resumable=False, retries=1) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(post_mock.await_count, 1) + self.assertEqual(get_mock.await_count, 4) + async def test_async_assembly_wait_does_not_follow_poll_response_assembly_url(self): initial_url = f"{self.server.base_url}/assemblies/assembly-123" @@ -1391,9 +1487,9 @@ async def test_async_assembly_retry_delay_sanitizes_response_info(self): self.assertEqual(assembly._retry_delay({"info": {"retryIn": float("nan")}}), 1) self.assertEqual(assembly._retry_delay({"info": {"retryIn": -2}}), 0) self.assertEqual(assembly._retry_delay({"info": {"retryIn": 0.25}}), 0.25) - self.assertEqual(assembly._retry_delay({"info": {"retryIn": 9999}}), 60) + self.assertEqual(assembly._retry_delay({"info": {"retryIn": 9999}}), 9999) - async def test_async_tus_upload_cancellation_returns_before_thread_finishes(self): + async def test_async_tus_upload_cancellation_waits_for_thread_to_finish(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) assembly = client.new_assembly() started = threading.Event() @@ -1418,13 +1514,13 @@ def blocking_upload(assembly_url, tus_url, retries): upload_task.cancel() await asyncio.sleep(0.05) - self.assertTrue(upload_task.done()) + self.assertFalse(upload_task.done()) self.assertFalse(finished.is_set()) + release.set() with self.assertRaises(asyncio.CancelledError): await upload_task - release.set() await asyncio.to_thread(finished.wait, 5) self.assertTrue(finished.is_set()) @@ -1478,7 +1574,10 @@ async def test_async_request_payload_preserves_custom_auth_constraints(self): self.assertEqual(params["auth"]["max_size"], 1024) self.assertEqual(params["auth"]["referer"], "https://example.com") - async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data(self): + with self.assertRaises(ValueError): + client.request._to_payload({"auth": "not-a-dict"}) + + async def test_async_request_filters_none_and_matches_sync_booleans_in_extra_data(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) upload = io.BytesIO(b"payload") @@ -1495,7 +1594,7 @@ async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data( fields = {field[0]["name"]: field for field in session.calls[0][1]["data"]._fields} self.assertIn("enabled", fields) self.assertNotIn("skip", fields) - self.assertEqual(fields["enabled"][2], "true") + self.assertEqual(fields["enabled"][2], "True") tag_values = [field[2] for field in session.calls[0][1]["data"]._fields if field[0]["name"] == "tags"] self.assertEqual(tag_values, ["a", "b"]) @@ -1508,9 +1607,14 @@ class _BrokenSeekableUpload(io.BytesIO): def seekable(self): raise OSError("seekable failed") + class _WriteOnlyUpload: + def readable(self): + return False + self.assertTrue(_NonClosingUploadStream(io.BytesIO(b"payload")).seekable()) self.assertFalse(_NonClosingUploadStream(_NonSeekableUpload(b"payload")).seekable()) self.assertFalse(_NonClosingUploadStream(_BrokenSeekableUpload(b"payload")).seekable()) + self.assertFalse(_NonClosingUploadStream(_WriteOnlyUpload()).readable()) async def test_async_request_uses_filename_fallback_for_trailing_slash_stream_name(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) diff --git a/tests/test_client.py b/tests/test_client.py index 156e856..df6ebc1 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -62,6 +62,11 @@ def assert_parity_with_node(self, url, params, message=''): if expected_url is not None: self.assertEqual(expected_url, url, message or 'URL should match Node.js reference implementation') + def test_rejects_invalid_service_url(self): + for service in ("", " ", "https://", "ftp://api2.transloadit.com"): + with self.assertRaises(ValueError): + Transloadit("key", "secret", service=service) + @requests_mock.Mocker() def test_get_assembly(self, mock): id_ = "abcdef12345" @@ -85,6 +90,23 @@ def test_quotes_path_ids(self): ], ) + def test_rejects_empty_template_ids(self): + invalid_ids = ("", None) + with mock.patch.object(self.transloadit.request, "get"): + for template_id in invalid_ids: + with self.assertRaises(ValueError): + self.transloadit.get_template(template_id) + + with mock.patch.object(self.transloadit.request, "put"): + for template_id in invalid_ids: + with self.assertRaises(ValueError): + self.transloadit.update_template(template_id, {"name": "foo"}) + + with mock.patch.object(self.transloadit.request, "delete"): + for template_id in invalid_ids: + with self.assertRaises(ValueError): + self.transloadit.delete_template(template_id) + @requests_mock.Mocker() def test_list_assemblies(self, mock): url = f"{self.transloadit.service}/assemblies" @@ -287,3 +309,19 @@ def test_get_signed_smart_cdn_url(self): # For parity test, set the exact expiry time to match Node.js params['expire_at_ms'] = expiry self.assert_parity_with_node(url, params) + + def test_get_signed_smart_cdn_url_rejects_invalid_workspace_and_reserved_params(self): + client = Transloadit("test-key", "test-secret") + + for workspace in ("", "-workspace", "workspace-", "Acme Workspace", "bad.workspace"): + with self.assertRaises(ValueError): + client.get_signed_smart_cdn_url(workspace, "template", "file.jpg") + + for reserved_key in ("auth_key", "exp", "sig"): + with self.assertRaises(ValueError): + client.get_signed_smart_cdn_url( + "workspace", + "template", + "file.jpg", + {reserved_key: "override"}, + ) diff --git a/tests/test_examples.py b/tests/test_examples.py index b2cdc6a..25a090b 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -59,6 +59,36 @@ def test_smart_cdn_example_runs_without_network(): assert "sig=sha256%3A" in result.stdout +def test_video_translator_download_uses_timeout(tmp_path, monkeypatch): + namespace = runpy.run_path( + str(EXAMPLES_ROOT / "video_translator.py"), + run_name="__example_import__", + ) + calls = [] + + class _Response: + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, tb): + return False + + def read(self): + return b'{"words":[]}' + + def urlopen(url, timeout): + calls.append((url, timeout)) + return _Response() + + monkeypatch.setattr(namespace["urllib"].request, "urlopen", urlopen) + output_path = tmp_path / "transcribe_json.json" + + namespace["download_url"]("https://example.com/transcribe_json.json", output_path, timeout=12) + + assert calls == [("https://example.com/transcribe_json.json", 12)] + assert output_path.read_text() == '{"words":[]}' + + @pytest.mark.e2e @pytest.mark.skipif(not _is_e2e_enabled(), reason="Set PYTHON_SDK_E2E=1 to run live examples") @pytest.mark.skipif( diff --git a/tests/test_request.py b/tests/test_request.py index a0ebf3b..e3daaaa 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -56,6 +56,10 @@ def test_payload_preserves_custom_auth_constraints(self): self.assertEqual(params["auth"]["max_size"], 1024) self.assertEqual(params["auth"]["referer"], "https://example.com") + def test_payload_rejects_malformed_auth_constraints(self): + with self.assertRaises(ValueError): + self.request._to_payload({"auth": "not-a-dict"}) + def test_full_url_allows_explicit_absolute_urls(self): self.assertEqual( self.request._get_full_url(f"{self.transloadit.service}/foo"), @@ -70,6 +74,17 @@ def test_full_url_allows_explicit_absolute_urls(self): "https://example.com/foo", ) + @requests_mock.Mocker() + def test_external_absolute_url_does_not_receive_signed_payload(self, mock): + url = "https://example.com/foo" + mock.get(url, text='{"ok": true}') + + response = self.request.get(url) + + self.assertTrue(response.data["ok"]) + self.assertNotIn("params", mock.last_request.qs) + self.assertNotIn("signature", mock.last_request.qs) + @requests_mock.Mocker() def test_put(self, mock): url = f"{self.transloadit.service}/foo" diff --git a/tests/test_response.py b/tests/test_response.py index 7949919..c5b28d3 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -21,6 +21,18 @@ def test_response_data_is_assignable_and_eager_for_sync_responses(self): self.assertEqual(response.status_code, 200) self.assertEqual(response.headers, {"X-Test": "1"}) + def test_response_uses_text_fallback_for_sync_non_json_responses(self): + raw = mock.Mock() + raw.json.side_effect = ValueError("not json") + raw.text = "bad gateway" + raw.status_code = 502 + raw.headers = {"Content-Type": "text/html"} + + response = Response(raw) + + self.assertEqual(response.data, "bad gateway") + self.assertEqual(response.status_code, 502) + def test_response_lazily_rehydrates_data_when_missing(self): raw = mock.Mock() raw.json.return_value = {"ok": "lazy"} diff --git a/transloadit/api_url.py b/transloadit/api_url.py new file mode 100644 index 0000000..192062d --- /dev/null +++ b/transloadit/api_url.py @@ -0,0 +1,47 @@ +from urllib.parse import urlparse + + +def normalize_service_url(service): + if not isinstance(service, str): + raise ValueError("service must be a URL string.") + + normalized_service = service.strip() + if not normalized_service: + raise ValueError("service must be a non-empty URL.") + if "://" in normalized_service and not normalized_service.startswith( + ("http://", "https://") + ): + raise ValueError("service must use http or https.") + if not normalized_service.startswith(("http://", "https://")): + normalized_service = "https://" + normalized_service + + parsed_service = urlparse(normalized_service) + if parsed_service.scheme not in {"http", "https"} or not parsed_service.netloc: + raise ValueError("service must include a valid host.") + return normalized_service + + +def require_path_id(value, name): + if value is None or not str(value).strip(): + raise ValueError(f"{name} cannot be empty.") + return str(value) + + +def should_sign_api_url(url, service): + if not url.startswith(("http://", "https://")): + return True + + parsed_url = urlparse(url) + parsed_service = urlparse(service) + # Only same-service URLs and Transloadit API regional hosts may receive auth params. + if ( + parsed_url.scheme == parsed_service.scheme + and parsed_url.netloc == parsed_service.netloc + ): + return True + + hostname = parsed_url.hostname or "" + return parsed_url.scheme == "https" and ( + hostname == "api2.transloadit.com" + or (hostname.startswith("api2-") and hostname.endswith(".transloadit.com")) + ) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 7b7d674..3aecb72 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -1,9 +1,9 @@ -import os from time import sleep from tusclient import client as tus from . import optionbuilder +from .upload import get_upload_filename class Assembly(optionbuilder.OptionBuilder): @@ -69,7 +69,7 @@ def _do_tus_upload(self, assembly_url, tus_url, retries): metadata = {"assembly_url": assembly_url} for key in self.files: metadata["fieldname"] = key - metadata["filename"] = os.path.basename(self.files[key].name) + metadata["filename"] = get_upload_filename(self.files[key], key) tus_client.uploader( file_stream=self.files[key], chunk_size=5 * 1024 * 1024, @@ -96,16 +96,28 @@ def create(self, wait=False, resumable=True, retries=3): response = self.transloadit.request.post( "/assemblies", extra_data=extra_data, data=data ) - self._do_tus_upload( - response.data.get("assembly_ssl_url"), - response.data.get("tus_url"), - retries, - ) else: response = self.transloadit.request.post( "/assemblies", data=data, files=self.files ) + if self._rate_limit_reached(response) and retries: + # wait till rate limit is expired + sleep(response.data.get("info", {}).get("retryIn", 1)) + return self.create(wait, resumable, retries - 1) + + if resumable and isinstance(response.data, dict): + if response.data.get("error") is not None: + return response + if self.files: + assembly_url = response.data.get("assembly_ssl_url") + tus_url = response.data.get("tus_url") + if not assembly_url or not tus_url: + raise RuntimeError( + f"Resumable assembly response is missing upload URLs: {response.data!r}" + ) + self._do_tus_upload(assembly_url, tus_url, retries) + if wait: while not self._assembly_finished(response): # if a wait period is provided by the API due to polling @@ -117,11 +129,6 @@ def create(self, wait=False, resumable=True, retries=3): assembly_url=response.data.get("assembly_ssl_url") ) - if self._rate_limit_reached(response) and retries: - # wait till rate limit is expired - sleep(response.data.get("info", {}).get("retryIn", 1)) - return self.create(wait, resumable, retries - 1) - return response def _assembly_finished(self, response): @@ -135,4 +142,7 @@ def _assembly_finished(self, response): return is_aborted or is_canceled or is_completed or (is_failed and not is_fetch_rate_limit) def _rate_limit_reached(self, response): - return response.data.get("error") == "RATE_LIMIT_REACHED" + return ( + isinstance(response.data, dict) + and response.data.get("error") == "RATE_LIMIT_REACHED" + ) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 0b1e62b..18ac00a 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -4,9 +4,7 @@ from tusclient import client as tus from . import optionbuilder -from .async_request import _get_upload_filename - -MAX_RETRY_DELAY_SECONDS = 60 +from .upload import get_upload_filename class AsyncAssembly(optionbuilder.OptionBuilder): @@ -67,7 +65,7 @@ def _rewind_files(self, positions): def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): - filename = _get_upload_filename(file_stream, key) + filename = get_upload_filename(file_stream, key) metadata = { "assembly_url": assembly_url, "fieldname": key, @@ -81,9 +79,20 @@ def _do_tus_upload(self, assembly_url, tus_url, retries): ).upload() async def _do_tus_upload_async(self, assembly_url, tus_url, retries): - # tuspy is synchronous: cancelling this awaiter cannot stop a worker thread already in flight. - # Returning cancellation promptly is safer than making callers wait on a stalled sync upload. - await asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) + # tuspy is synchronous, so cancellation cannot abort an upload already running in + # the worker thread. Wait for the worker to release file streams before letting + # cancellation unwind caller-owned file context managers. + upload_task = asyncio.create_task( + asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) + ) + try: + await asyncio.shield(upload_task) + except asyncio.CancelledError: + try: + await upload_task + except Exception: + pass + raise async def create(self, wait=False, resumable=True, retries=3): """ @@ -135,7 +144,9 @@ async def create(self, wait=False, resumable=True, retries=3): if resumable and self.files: if not assembly_url or not tus_url: - raise RuntimeError("Resumable assembly response is missing upload URLs.") + raise RuntimeError( + f"Resumable assembly response is missing upload URLs: {response_data!r}" + ) await self._do_tus_upload_async(assembly_url, tus_url, tus_retries) if wait: @@ -150,6 +161,8 @@ async def create(self, wait=False, resumable=True, retries=3): if remaining_rate_limit_retries <= 0: return poll_response remaining_rate_limit_retries -= 1 + else: + remaining_rate_limit_retries = poll_retries sleep_time = self._retry_delay(poll_data) await asyncio.sleep(sleep_time) poll_response = await self.transloadit.get_assembly( @@ -176,7 +189,12 @@ def _assembly_finished(self, response_data): is_failed = error is not None is_fetch_rate_limit = error == "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED" is_submit_rate_limit = error == "RATE_LIMIT_REACHED" - return is_aborted or is_canceled or is_completed or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) + return ( + is_aborted + or is_canceled + or is_completed + or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) + ) def _rate_limit_reached(self, response_data): error = response_data.get("error") @@ -195,4 +213,4 @@ def _retry_delay(self, response_data): return 1 if not math.isfinite(delay): return 1 - return min(max(delay, 0), MAX_RETRY_DELAY_SECONDS) + return max(delay, 0) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index eaa4699..683c5a7 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -1,16 +1,9 @@ -import hashlib -import hmac -import time -from typing import List, Optional, Union -from urllib.parse import quote, quote_plus, urlencode +from typing import Optional +from urllib.parse import quote from . import async_assembly, async_request, async_template - - -def _stringify_url_param(value: Union[str, int, float, bool]) -> str: - if isinstance(value, bool): - return "true" if value else "false" - return str(value) +from .api_url import normalize_service_url, require_path_id +from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url def _quote_path_segment(value: str) -> str: @@ -30,10 +23,7 @@ def __init__( duration: int = 300, session=None, ): - if not service.startswith(("http://", "https://")): - service = "https://" + service - - self.service = service + self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration @@ -88,6 +78,7 @@ async def get_template(self, template_id: str): """ Get the template specified by the 'template_id'. """ + template_id = require_path_id(template_id, "template_id") return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") async def list_templates(self, params: Optional[dict] = None): @@ -106,12 +97,14 @@ async def update_template(self, template_id: str, data: dict): """ Update the template specified by the 'template_id'. """ + template_id = require_path_id(template_id, "template_id") return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) async def delete_template(self, template_id: str): """ Delete the template specified by the 'template_id'. """ + template_id = require_path_id(template_id, "template_id") return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") async def get_bill(self, month: int, year: int): @@ -125,44 +118,18 @@ def get_signed_smart_cdn_url( workspace: str, template: str, input: str, - url_params: Optional[dict[str, Union[str, int, float, bool, List[Union[str, int, float, bool]], None]]] = None, + url_params: Optional[dict[str, URL_PARAM_VALUES]] = None, expires_at_ms: Optional[int] = None, ) -> str: """ Construct a signed Smart CDN URL. """ - workspace_slug = quote_plus(workspace) - template_slug = quote_plus(template) - input_field = quote_plus(input) - - expiry = expires_at_ms if expires_at_ms is not None else int(time.time() * 1000) + 60 * 60 * 1000 - - params = [] - if url_params: - for k, v in url_params.items(): - if v is None: - continue - elif isinstance(v, (str, int, float, bool)): - params.append((k, _stringify_url_param(v))) - elif isinstance(v, (list, tuple)): - params.append((k, [_stringify_url_param(vv) for vv in v])) - else: - raise ValueError( - f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}" - ) - - params.append(("auth_key", self.auth_key)) - params.append(("exp", str(expiry))) - sorted_params = sorted(params, key=lambda x: x[0]) - query_string = urlencode(sorted_params, doseq=True) - - string_to_sign = f"{workspace_slug}/{template_slug}/{input_field}?{query_string}" - algorithm = "sha256" - - signature = algorithm + ":" + hmac.new( - self.auth_secret.encode("utf-8"), - string_to_sign.encode("utf-8"), - hashlib.sha256, - ).hexdigest() - - return f"https://{workspace_slug}.tlcdn.com/{template_slug}/{input_field}?{query_string}&sig={quote_plus(signature)}" + return build_signed_smart_cdn_url( + auth_key=self.auth_key, + auth_secret=self.auth_secret, + workspace=workspace, + template=template, + input=input, + url_params=url_params, + expires_at_ms=expires_at_ms, + ) diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 4937bf5..65f8495 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -1,35 +1,25 @@ import asyncio -import io -import mimetypes -import os import copy import hashlib import hmac +import io import json -from types import MappingProxyType +import mimetypes +import os from datetime import datetime, timedelta, timezone +from types import MappingProxyType import aiohttp from requests.structures import CaseInsensitiveDict from . import __version__ +from .api_url import should_sign_api_url from .response import Response +from .upload import get_upload_filename TIMEOUT = 60 -def _get_upload_filename(file_stream, fallback): - name = getattr(file_stream, "name", None) - if isinstance(name, (bytes, os.PathLike)): - name = os.fsdecode(name) - - if isinstance(name, str): - filename = os.path.basename(name) - if filename: - return filename - return fallback - - class _NonClosingUploadStream(io.IOBase): def __init__(self, file_stream): self._file_stream = file_stream @@ -48,7 +38,13 @@ def read(self, *args): return self._file_stream.read(*args) def readable(self): - return True + readable = getattr(self._file_stream, "readable", None) + if callable(readable): + try: + return readable() + except (OSError, ValueError): + return False + return hasattr(self._file_stream, "read") def readline(self, *args): return self._file_stream.readline(*args) @@ -118,7 +114,7 @@ async def aclose(self): await self._session.close() self._session = None - def _timeout(self, files=False): + def _timeout(self): # Keep total disabled for large request bodies, but still cap stalled responses. return aiohttp.ClientTimeout( total=None, @@ -135,10 +131,7 @@ def _normalize_payload(self, data): for item in values: if item is None: continue - if isinstance(item, bool): - normalized.append((key, "true" if item else "false")) - else: - normalized.append((key, str(item))) + normalized.append((key, str(item))) return normalized async def _read_response_data(self, response): @@ -158,7 +151,7 @@ async def get(self, path, params=None): session = await self._ensure_session() async with session.get( url, - params=self._to_payload(params), + params=self._to_request_payload(url, params), headers=self._headers(), timeout=self._timeout(), ) as response: @@ -174,7 +167,7 @@ async def post(self, path, data=None, extra_data=None, files=None): """ url = self._get_full_url(path) session = await self._ensure_session() - data = self._to_payload(data) + data = self._to_request_payload(url, data) or {} if extra_data: data.update(extra_data) @@ -184,7 +177,7 @@ async def post(self, path, data=None, extra_data=None, files=None): form.add_field(key, value) for key, file_stream in files.items(): - filename = _get_upload_filename(file_stream, key) + filename = get_upload_filename(file_stream, key) content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" form.add_field( key, @@ -200,7 +193,7 @@ async def post(self, path, data=None, extra_data=None, files=None): url, data=payload, headers=self._headers(), - timeout=self._timeout(files=bool(files)), + timeout=self._timeout(), ) as response: return Response( data=await self._read_response_data(response), @@ -214,7 +207,7 @@ async def put(self, path, data=None): """ url = self._get_full_url(path) session = await self._ensure_session() - data = self._normalize_payload(self._to_payload(data)) + data = self._normalize_payload(self._to_request_payload(url, data) or {}) async with session.put( url, data=data, @@ -233,7 +226,7 @@ async def delete(self, path, data=None): """ url = self._get_full_url(path) session = await self._ensure_session() - data = self._normalize_payload(self._to_payload(data)) + data = self._normalize_payload(self._to_request_payload(url, data) or {}) async with session.delete( url, data=data, @@ -249,7 +242,9 @@ async def delete(self, path, data=None): def _to_payload(self, data): data = copy.deepcopy(data or {}) expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) - auth = data.get("auth") if isinstance(data.get("auth"), dict) else {} + if "auth" in data and not isinstance(data["auth"], dict): + raise ValueError("auth must be a dictionary when provided.") + auth = data.get("auth") or {} auth.update({ "key": self.transloadit.auth_key, "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"), @@ -258,6 +253,11 @@ def _to_payload(self, data): json_data = json.dumps(data) return {"params": json_data, "signature": self._sign_data(json_data)} + def _to_request_payload(self, url, data): + if should_sign_api_url(url, self.transloadit.service): + return self._to_payload(data) + return copy.deepcopy(data) if data else None + def _sign_data(self, message): hash_string = hmac.new( self.transloadit.auth_secret.encode("utf-8"), message.encode("utf-8"), hashlib.sha384 diff --git a/transloadit/client.py b/transloadit/client.py index 74c9b96..854da46 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -1,23 +1,15 @@ import typing -import hmac -import hashlib -import time -from urllib.parse import quote, quote_plus, urlencode - -from typing import Optional, Union, List +from typing import Optional +from urllib.parse import quote from . import assembly, request, template +from .api_url import normalize_service_url, require_path_id +from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url if typing.TYPE_CHECKING: from requests import Response -def _stringify_url_param(value: Union[str, int, float, bool]) -> str: - if isinstance(value, bool): - return "true" if value else "false" - return str(value) - - def _quote_path_segment(value: str) -> str: return quote(str(value), safe="") @@ -51,10 +43,7 @@ def __init__( service: str = "https://api2.transloadit.com", duration: int = 300, ): - if not service.startswith(("http://", "https://")): - service = "https://" + service - - self.service = service + self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration @@ -123,6 +112,7 @@ def get_template(self, template_id: str): Return an instance of """ + template_id = require_path_id(template_id, "template_id") return self.request.get(f"/templates/{_quote_path_segment(template_id)}") def list_templates(self, params: Optional[dict] = None): @@ -158,6 +148,7 @@ def update_template(self, template_id: str, data: dict): Return an instance of """ + template_id = require_path_id(template_id, "template_id") return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) def delete_template(self, template_id: str): @@ -169,6 +160,7 @@ def delete_template(self, template_id: str): Return an instance of """ + template_id = require_path_id(template_id, "template_id") return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") def get_bill(self, month: int, year: int): @@ -188,8 +180,8 @@ def get_signed_smart_cdn_url( workspace: str, template: str, input: str, - url_params: Optional[dict[str, Union[str, int, float, bool, List[Union[str, int, float, bool]], None]]] = None, - expires_at_ms: Optional[int] = None + url_params: Optional[dict[str, URL_PARAM_VALUES]] = None, + expires_at_ms: Optional[int] = None, ) -> str: """ Construct a signed Smart CDN URL. @@ -208,38 +200,12 @@ def get_signed_smart_cdn_url( :Raises: ValueError: If url_params contains values that are not strings, numbers, booleans, arrays, or None """ - workspace_slug = quote_plus(workspace) - template_slug = quote_plus(template) - input_field = quote_plus(input) - - expiry = expires_at_ms if expires_at_ms is not None else int(time.time() * 1000) + 60 * 60 * 1000 # 1 hour default - - params = [] - if url_params: - for k, v in url_params.items(): - if v is None: - continue # Skip None values - elif isinstance(v, (str, int, float, bool)): - params.append((k, _stringify_url_param(v))) - elif isinstance(v, (list, tuple)): - params.append((k, [_stringify_url_param(vv) for vv in v])) - else: - raise ValueError(f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}") - - params.append(("auth_key", self.auth_key)) - params.append(("exp", str(expiry))) - - # Sort params alphabetically by key - sorted_params = sorted(params, key=lambda x: x[0]) - query_string = urlencode(sorted_params, doseq=True) - - string_to_sign = f"{workspace_slug}/{template_slug}/{input_field}?{query_string}" - algorithm = "sha256" - - signature = algorithm + ":" + hmac.new( - self.auth_secret.encode("utf-8"), - string_to_sign.encode("utf-8"), - hashlib.sha256 - ).hexdigest() - - return f"https://{workspace_slug}.tlcdn.com/{template_slug}/{input_field}?{query_string}&sig={quote_plus(signature)}" + return build_signed_smart_cdn_url( + auth_key=self.auth_key, + auth_secret=self.auth_secret, + workspace=workspace, + template=template, + input=input, + url_params=url_params, + expires_at_ms=expires_at_ms, + ) diff --git a/transloadit/request.py b/transloadit/request.py index a17b7fc..ca35236 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -1,16 +1,18 @@ +import copy import hashlib import hmac import json -import copy from datetime import datetime, timedelta, timezone import requests -from .response import as_response from . import __version__ +from .api_url import should_sign_api_url +from .response import as_response TIMEOUT = 60 + class Request: """ Transloadit tailored HTTP Request object. @@ -39,9 +41,10 @@ def get(self, path, params=None): Return an instance of """ + url = self._get_full_url(path) return requests.get( - self._get_full_url(path), - params=self._to_payload(params), + url, + params=self._to_request_payload(url, params), headers=self.HEADERS, timeout=TIMEOUT, ) @@ -61,11 +64,14 @@ def post(self, path, data=None, extra_data=None, files=None): Return an instance of """ - data = self._to_payload(data) + url = self._get_full_url(path) + data = self._to_request_payload(url, data) if extra_data: + if data is None: + data = {} data.update(extra_data) return requests.post( - self._get_full_url(path), + url, data=data, files=files, headers=self.HEADERS, @@ -83,9 +89,10 @@ def put(self, path, data=None): Return an instance of """ - data = self._to_payload(data) + url = self._get_full_url(path) + data = self._to_request_payload(url, data) return requests.put( - self._get_full_url(path), + url, data=data, headers=self.HEADERS, timeout=TIMEOUT, @@ -102,9 +109,10 @@ def delete(self, path, data=None): Return an instance of """ - data = self._to_payload(data) + url = self._get_full_url(path) + data = self._to_request_payload(url, data) return requests.delete( - self._get_full_url(path), + url, data=data, headers=self.HEADERS, timeout=TIMEOUT, @@ -113,7 +121,9 @@ def delete(self, path, data=None): def _to_payload(self, data): data = copy.deepcopy(data or {}) expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) - auth = data.get("auth") if isinstance(data.get("auth"), dict) else {} + if "auth" in data and not isinstance(data["auth"], dict): + raise ValueError("auth must be a dictionary when provided.") + auth = data.get("auth") or {} auth.update({ "key": self.transloadit.auth_key, "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"), @@ -122,6 +132,11 @@ def _to_payload(self, data): json_data = json.dumps(data) return {"params": json_data, "signature": self._sign_data(json_data)} + def _to_request_payload(self, url, data): + if should_sign_api_url(url, self.transloadit.service): + return self._to_payload(data) + return copy.deepcopy(data) if data else None + def _sign_data(self, message): hash_string = hmac.new( self.transloadit.auth_secret.encode("utf-8"), message.encode("utf-8"), hashlib.sha384 diff --git a/transloadit/response.py b/transloadit/response.py index 7e5b289..51b08f8 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -27,17 +27,26 @@ class Response: def __init__(self, response=None, data=_MISSING, status_code=_MISSING, headers=_MISSING): self._response = response if data is _MISSING and response is not None: - data = response.json() + data = self._read_sync_response_data() self._data = data self._status_code = status_code self._headers = headers + def _read_sync_response_data(self): + try: + return self._response.json() + except ValueError: + try: + return self._response.text + except UnicodeDecodeError: + return self._response.content + @property def data(self): if self._data is _MISSING: if self._response is None: return None - self._data = self._response.json() + self._data = self._read_sync_response_data() return self._data @data.setter diff --git a/transloadit/smart_cdn.py b/transloadit/smart_cdn.py new file mode 100644 index 0000000..8c9880f --- /dev/null +++ b/transloadit/smart_cdn.py @@ -0,0 +1,89 @@ +import hashlib +import hmac +import re +import time +from typing import List, Optional, Tuple, Union +from urllib.parse import quote_plus, urlencode + +URL_PARAM_VALUE = Union[str, int, float, bool] +URL_PARAM_VALUES = Union[ + URL_PARAM_VALUE, + List[URL_PARAM_VALUE], + Tuple[URL_PARAM_VALUE, ...], + None, +] +RESERVED_URL_PARAMS = {"auth_key", "exp", "sig"} +WORKSPACE_SLUG_PATTERN = re.compile(r"^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$") + + +def _stringify_url_param(value: URL_PARAM_VALUE) -> str: + if isinstance(value, bool): + return "true" if value else "false" + return str(value) + + +def _validate_workspace_slug(workspace: str) -> str: + if not WORKSPACE_SLUG_PATTERN.fullmatch(workspace): + raise ValueError( + "workspace must be a DNS-safe Smart CDN workspace slug: " + "letters, numbers, and hyphens only, without leading or trailing hyphens" + ) + return workspace + + +def build_signed_smart_cdn_url( + *, + auth_key: str, + auth_secret: str, + workspace: str, + template: str, + input: str, + url_params: Optional[dict[str, URL_PARAM_VALUES]] = None, + expires_at_ms: Optional[int] = None, +) -> str: + workspace_slug = quote_plus(_validate_workspace_slug(workspace)) + template_slug = quote_plus(template) + input_field = quote_plus(input) + + expiry = ( + expires_at_ms + if expires_at_ms is not None + else int(time.time() * 1000) + 60 * 60 * 1000 + ) + + params = [] + if url_params: + for key, value in url_params.items(): + if key.lower() in RESERVED_URL_PARAMS: + raise ValueError( + f"url_params must not include reserved Smart CDN parameter {key!r}" + ) + if value is None: + continue + if isinstance(value, (str, int, float, bool)): + params.append((key, _stringify_url_param(value))) + elif isinstance(value, (list, tuple)): + params.append((key, [_stringify_url_param(item) for item in value])) + else: + raise ValueError( + "URL parameter values must be strings, numbers, booleans, arrays, " + f"or None. Got {type(value)} for {key}" + ) + + params.append(("auth_key", auth_key)) + params.append(("exp", str(expiry))) + sorted_params = sorted(params, key=lambda item: item[0]) + query_string = urlencode(sorted_params, doseq=True) + + string_to_sign = f"{workspace_slug}/{template_slug}/{input_field}?{query_string}" + algorithm = "sha256" + signature = algorithm + ":" + hmac.new( + auth_secret.encode("utf-8"), + string_to_sign.encode("utf-8"), + hashlib.sha256, + ).hexdigest() + + return ( + f"https://{workspace_slug}.tlcdn.com/{template_slug}/{input_field}" + f"?{query_string}&sig={quote_plus(signature)}" + ) diff --git a/transloadit/upload.py b/transloadit/upload.py new file mode 100644 index 0000000..7803f68 --- /dev/null +++ b/transloadit/upload.py @@ -0,0 +1,13 @@ +import os + + +def get_upload_filename(file_stream, fallback): + name = getattr(file_stream, "name", None) + if isinstance(name, (bytes, os.PathLike)): + name = os.fsdecode(name) + + if isinstance(name, str): + filename = os.path.basename(name) + if filename: + return filename + return fallback From bb04389548c656a5c6739da9ca60ce397c7f7df6 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 21 May 2026 16:07:38 +0200 Subject: [PATCH 22/64] Note endpoint coverage TODO --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2700f05..043f196 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,5 @@ ### 2.0.0 / 2026-05-20 ### +* @TODO before merging: expand the SDK surface so this release supports all Transloadit API endpoints, and update these release notes with the final endpoint coverage. * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async polling rate-limit retries reset after successful polls, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. From a779f9eeec82c0c1a99e0f01bb8beeb39a009845 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 23 May 2026 18:22:56 +0200 Subject: [PATCH 23/64] Add generated low-level endpoint methods --- tests/test_async_client.py | 104 ++++++++++++++++++++++++++++++ tests/test_client.py | 98 +++++++++++++++++++++++++++++ transloadit/async_client.py | 122 ++++++++++++++++++++++++++++++++++++ transloadit/client.py | 122 ++++++++++++++++++++++++++++++++++++ 4 files changed, 446 insertions(+) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index bc12310..d989718 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -457,6 +457,110 @@ async def test_async_client_rejects_empty_template_ids(self): self.assertEqual(session.calls, []) + async def test_async_generated_endpoint_methods_call_request_helpers(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + response = Response(data={"ok": "OK"}, status_code=200, headers={}) + assembly_data = {"steps": {":original": {"robot": "/upload/handle"}}} + extra_data = {"field": "value"} + files = {"file": io.BytesIO(b"payload")} + replay_data = {"wait": True} + credential_data = {"name": "demo", "type": "s3", "content": {}} + + get_mock = mock.AsyncMock(return_value=response) + post_mock = mock.AsyncMock(return_value=response) + put_mock = mock.AsyncMock(return_value=response) + delete_mock = mock.AsyncMock(return_value=response) + + with mock.patch.object(client.request, "get", new=get_mock): + with mock.patch.object(client.request, "post", new=post_mock): + with mock.patch.object(client.request, "put", new=put_mock): + with mock.patch.object(client.request, "delete", new=delete_mock): + await client.create_assembly(assembly_data, extra_data, files) + await client.create_assembly_with_id( + "assembly/with?chars", assembly_data, extra_data, files + ) + await client.replay_assembly("assembly/with?chars", replay_data) + await client.replay_assembly_notification( + "assembly/with?chars", replay_data + ) + await client.create_template({"name": "template"}) + await client.validate_template_credential_oauth_on_create( + {"type": "dropbox"} + ) + await client.create_template_credentials(credential_data) + await client.list_assembly_notifications("assembly/with?chars") + await client.get_builtin_template("builtin/with?chars") + await client.get_template_full("template/with?chars") + await client.get_builtin_template_full("builtin/full?chars") + await client.list_priority_job_slots() + await client.list_template_credentials() + await client.list_template_credential_types() + await client.get_template_credentials("cred/with?chars") + await client.update_template_credentials("cred/with?chars", credential_data) + await client.delete_template_credentials("cred/with?chars") + + self.assertEqual( + post_mock.await_args_list, + [ + mock.call( + "/assemblies", + data=assembly_data, + extra_data=extra_data, + files=files, + ), + mock.call( + "/assemblies/assembly%2Fwith%3Fchars", + data=assembly_data, + extra_data=extra_data, + files=files, + ), + mock.call("/assemblies/assembly%2Fwith%3Fchars/replay", data=replay_data), + mock.call( + "/assembly_notifications/assembly%2Fwith%3Fchars/replay", + data=replay_data, + ), + mock.call("/templates", data={"name": "template"}), + mock.call("/template_credentials/validateOauthOnCreate", data={"type": "dropbox"}), + mock.call("/template_credentials", data=credential_data), + ], + ) + self.assertEqual( + get_mock.await_args_list, + [ + mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), + mock.call("/templates/builtin/builtin%2Fwith%3Fchars"), + mock.call("/templates/template%2Fwith%3Fchars/full"), + mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full"), + mock.call("/queues/job_slots"), + mock.call("/template_credentials"), + mock.call("/template_credentials/types"), + mock.call("/template_credentials/cred%2Fwith%3Fchars"), + ], + ) + put_mock.assert_awaited_once_with( + "/template_credentials/cred%2Fwith%3Fchars", data=credential_data + ) + delete_mock.assert_awaited_once_with("/template_credentials/cred%2Fwith%3Fchars") + + async def test_async_generated_endpoint_methods_reject_empty_path_ids(self): + client = AsyncTransloadit("key", "secret", service=self.server.base_url) + methods = [ + client.create_assembly_with_id, + client.replay_assembly, + client.replay_assembly_notification, + client.list_assembly_notifications, + client.get_builtin_template, + client.get_template_full, + client.get_builtin_template_full, + client.get_template_credentials, + client.delete_template_credentials, + client.update_template_credentials, + ] + + for method in methods: + with self.assertRaises(ValueError): + await method("") + async def test_async_client_close_reopens_owned_session(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) diff --git a/tests/test_client.py b/tests/test_client.py index df6ebc1..ad4cf43 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -107,6 +107,104 @@ def test_rejects_empty_template_ids(self): with self.assertRaises(ValueError): self.transloadit.delete_template(template_id) + def test_generated_endpoint_methods_call_request_helpers(self): + assembly_data = {"steps": {":original": {"robot": "/upload/handle"}}} + extra_data = {"field": "value"} + files = {"file": object()} + replay_data = {"wait": True} + credential_data = {"name": "demo", "type": "s3", "content": {}} + + with mock.patch.object(self.transloadit.request, "get") as get_mock: + with mock.patch.object(self.transloadit.request, "post") as post_mock: + with mock.patch.object(self.transloadit.request, "put") as put_mock: + with mock.patch.object(self.transloadit.request, "delete") as delete_mock: + self.transloadit.create_assembly(assembly_data, extra_data, files) + self.transloadit.create_assembly_with_id( + "assembly/with?chars", assembly_data, extra_data, files + ) + self.transloadit.replay_assembly("assembly/with?chars", replay_data) + self.transloadit.replay_assembly_notification( + "assembly/with?chars", replay_data + ) + self.transloadit.create_template({"name": "template"}) + self.transloadit.validate_template_credential_oauth_on_create( + {"type": "dropbox"} + ) + self.transloadit.create_template_credentials(credential_data) + self.transloadit.list_assembly_notifications("assembly/with?chars") + self.transloadit.get_builtin_template("builtin/with?chars") + self.transloadit.get_template_full("template/with?chars") + self.transloadit.get_builtin_template_full("builtin/full?chars") + self.transloadit.list_priority_job_slots() + self.transloadit.list_template_credentials() + self.transloadit.list_template_credential_types() + self.transloadit.get_template_credentials("cred/with?chars") + self.transloadit.update_template_credentials( + "cred/with?chars", credential_data + ) + self.transloadit.delete_template_credentials("cred/with?chars") + + self.assertEqual( + post_mock.call_args_list, + [ + mock.call( + "/assemblies", + data=assembly_data, + extra_data=extra_data, + files=files, + ), + mock.call( + "/assemblies/assembly%2Fwith%3Fchars", + data=assembly_data, + extra_data=extra_data, + files=files, + ), + mock.call("/assemblies/assembly%2Fwith%3Fchars/replay", data=replay_data), + mock.call( + "/assembly_notifications/assembly%2Fwith%3Fchars/replay", + data=replay_data, + ), + mock.call("/templates", data={"name": "template"}), + mock.call("/template_credentials/validateOauthOnCreate", data={"type": "dropbox"}), + mock.call("/template_credentials", data=credential_data), + ], + ) + self.assertEqual( + get_mock.call_args_list, + [ + mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), + mock.call("/templates/builtin/builtin%2Fwith%3Fchars"), + mock.call("/templates/template%2Fwith%3Fchars/full"), + mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full"), + mock.call("/queues/job_slots"), + mock.call("/template_credentials"), + mock.call("/template_credentials/types"), + mock.call("/template_credentials/cred%2Fwith%3Fchars"), + ], + ) + put_mock.assert_called_once_with( + "/template_credentials/cred%2Fwith%3Fchars", data=credential_data + ) + delete_mock.assert_called_once_with("/template_credentials/cred%2Fwith%3Fchars") + + def test_generated_endpoint_methods_reject_empty_path_ids(self): + methods = [ + self.transloadit.create_assembly_with_id, + self.transloadit.replay_assembly, + self.transloadit.replay_assembly_notification, + self.transloadit.list_assembly_notifications, + self.transloadit.get_builtin_template, + self.transloadit.get_template_full, + self.transloadit.get_builtin_template_full, + self.transloadit.get_template_credentials, + self.transloadit.delete_template_credentials, + self.transloadit.update_template_credentials, + ] + + for method in methods: + with self.assertRaises(ValueError): + method("") + @requests_mock.Mocker() def test_list_assemblies(self, mock): url = f"{self.transloadit.service}/assemblies" diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 683c5a7..d47f8f6 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -48,6 +48,20 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: """ return async_assembly.AsyncAssembly(self, options=params) + async def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): + """ + Create a new Assembly. + """ + return await self.request.post("/assemblies", data=data, extra_data=extra_data, files=files) + + async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): + """ + Create Assembly With Id. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return await self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Get the assembly specified by the 'assembly_id' or the 'assembly_url'. @@ -74,6 +88,30 @@ async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = Non url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return await self.request.delete(url) + async def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): + """ + Replay an Assembly. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return await self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}/replay", data=data) + + async def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): + """ + Replay Assembly Notification. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return await self.request.post(f"/assembly_notifications/{_quote_path_segment(assembly_id)}/replay", data=data) + + async def list_assembly_notifications(self, assembly_id: str): + """ + List Assembly Notifications. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return await self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + async def get_template(self, template_id: str): """ Get the template specified by the 'template_id'. @@ -81,12 +119,42 @@ async def get_template(self, template_id: str): template_id = require_path_id(template_id, "template_id") return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") + async def get_builtin_template(self, builtin_template_slug: str): + """ + Get Builtin Template. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}") + + async def get_template_full(self, template_id_or_name: str): + """ + Get Template Full. + """ + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + + return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full") + + async def get_builtin_template_full(self, builtin_template_slug: str): + """ + Get Builtin Template Full. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") + async def list_templates(self, params: Optional[dict] = None): """ Get the list of templates. """ return await self.request.get("/templates", params=params) + async def create_template(self, data: Optional[dict] = None): + """ + Create a new Template. + """ + return await self.request.post("/templates", data=data) + def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: """ Return an instance of . @@ -107,6 +175,60 @@ async def delete_template(self, template_id: str): template_id = require_path_id(template_id, "template_id") return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") + async def list_priority_job_slots(self): + """ + Retrieve currently used priority job slots. + """ + return await self.request.get("/queues/job_slots") + + async def list_template_credentials(self): + """ + Retrieve list of Template Credentials. + """ + return await self.request.get("/template_credentials") + + async def list_template_credential_types(self): + """ + List Template Credential Types. + """ + return await self.request.get("/template_credentials/types") + + async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + """ + Validate Template Credential OAuth On Create. + """ + return await self.request.post("/template_credentials/validateOauthOnCreate", data=data) + + async def create_template_credentials(self, data: Optional[dict] = None): + """ + Create a new Template Credential. + """ + return await self.request.post("/template_credentials", data=data) + + async def get_template_credentials(self, identifier: str): + """ + Retrieve a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return await self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}") + + async def delete_template_credentials(self, identifier: str): + """ + Delete a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return await self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}") + + async def update_template_credentials(self, identifier: str, data: Optional[dict] = None): + """ + Edit a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return await self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + async def get_bill(self, month: int, year: int): """ Get the bill for the specified month and year. diff --git a/transloadit/client.py b/transloadit/client.py index 854da46..b20772f 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -56,6 +56,20 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: """ return assembly.Assembly(self, options=params) + def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): + """ + Create a new Assembly. + """ + return self.request.post("/assemblies", data=data, extra_data=extra_data, files=files) + + def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): + """ + Create Assembly With Id. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Get the assembly specified by the 'assembly_id' or the 'assembly_url' @@ -103,6 +117,30 @@ def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return self.request.delete(url) + def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): + """ + Replay an Assembly. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}/replay", data=data) + + def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): + """ + Replay Assembly Notification. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return self.request.post(f"/assembly_notifications/{_quote_path_segment(assembly_id)}/replay", data=data) + + def list_assembly_notifications(self, assembly_id: str): + """ + List Assembly Notifications. + """ + assembly_id = require_path_id(assembly_id, "assembly_id") + + return self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + def get_template(self, template_id: str): """ Get the template specified by the 'template_id'. @@ -115,6 +153,30 @@ def get_template(self, template_id: str): template_id = require_path_id(template_id, "template_id") return self.request.get(f"/templates/{_quote_path_segment(template_id)}") + def get_builtin_template(self, builtin_template_slug: str): + """ + Get Builtin Template. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}") + + def get_template_full(self, template_id_or_name: str): + """ + Get Template Full. + """ + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + + return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full") + + def get_builtin_template_full(self, builtin_template_slug: str): + """ + Get Builtin Template Full. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") + def list_templates(self, params: Optional[dict] = None): """ Get the list of templates. @@ -128,6 +190,12 @@ def list_templates(self, params: Optional[dict] = None): """ return self.request.get("/templates", params=params) + def create_template(self, data: Optional[dict] = None): + """ + Create a new Template. + """ + return self.request.post("/templates", data=data) + def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: """ Return an instance of which would be used to create @@ -163,6 +231,60 @@ def delete_template(self, template_id: str): template_id = require_path_id(template_id, "template_id") return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") + def list_priority_job_slots(self): + """ + Retrieve currently used priority job slots. + """ + return self.request.get("/queues/job_slots") + + def list_template_credentials(self): + """ + Retrieve list of Template Credentials. + """ + return self.request.get("/template_credentials") + + def list_template_credential_types(self): + """ + List Template Credential Types. + """ + return self.request.get("/template_credentials/types") + + def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + """ + Validate Template Credential OAuth On Create. + """ + return self.request.post("/template_credentials/validateOauthOnCreate", data=data) + + def create_template_credentials(self, data: Optional[dict] = None): + """ + Create a new Template Credential. + """ + return self.request.post("/template_credentials", data=data) + + def get_template_credentials(self, identifier: str): + """ + Retrieve a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}") + + def delete_template_credentials(self, identifier: str): + """ + Delete a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}") + + def update_template_credentials(self, identifier: str, data: Optional[dict] = None): + """ + Edit a Template Credential. + """ + identifier = require_path_id(identifier, "identifier") + + return self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + def get_bill(self, month: int, year: int): """ Get the bill for the specified month and year. From 3cd48ac05cc0fb2f7b56406918f1642498fa794a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 23 May 2026 20:41:42 +0200 Subject: [PATCH 24/64] Mark generated endpoint method blocks --- transloadit/async_client.py | 15 +++++++++------ transloadit/client.py | 23 +++++++++++++---------- 2 files changed, 22 insertions(+), 16 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index d47f8f6..4693415 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -48,6 +48,7 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: """ return async_assembly.AsyncAssembly(self, options=params) + # async def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. @@ -155,12 +156,6 @@ async def create_template(self, data: Optional[dict] = None): """ return await self.request.post("/templates", data=data) - def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: - """ - Return an instance of . - """ - return async_template.AsyncTemplate(self, name, options=params) - async def update_template(self, template_id: str, data: dict): """ Update the template specified by the 'template_id'. @@ -235,6 +230,14 @@ async def get_bill(self, month: int, year: int): """ return await self.request.get(f"/bill/{year}-{month:02d}") + # + + def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: + """ + Return an instance of . + """ + return async_template.AsyncTemplate(self, name, options=params) + def get_signed_smart_cdn_url( self, workspace: str, diff --git a/transloadit/client.py b/transloadit/client.py index b20772f..287f316 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -56,6 +56,7 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: """ return assembly.Assembly(self, options=params) + # def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. @@ -196,16 +197,6 @@ def create_template(self, data: Optional[dict] = None): """ return self.request.post("/templates", data=data) - def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: - """ - Return an instance of which would be used to create - a new template. - - :Args: - - name (str): Name of the template. - """ - return template.Template(self, name, options=params) - def update_template(self, template_id: str, data: dict): """ Update the template specified by the 'template_id'. @@ -297,6 +288,18 @@ def get_bill(self, month: int, year: int): """ return self.request.get(f"/bill/{year}-{month:02d}") + # + + def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: + """ + Return an instance of which would be used to create + a new template. + + :Args: + - name (str): Name of the template. + """ + return template.Template(self, name, options=params) + def get_signed_smart_cdn_url( self, workspace: str, From 8090d14d04400a39514dc1da422d12370cce4c88 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 24 May 2026 11:16:28 +0200 Subject: [PATCH 25/64] Harden sync assembly retries and generated docs --- CHANGELOG.md | 4 +- tests/test_api_url.py | 14 +++ tests/test_assembly.py | 205 ++++++++++++++++++++++++++++++++++++ transloadit/api_url.py | 5 +- transloadit/assembly.py | 180 ++++++++++++++++++++++--------- transloadit/async_client.py | 16 +-- transloadit/client.py | 66 ++---------- 7 files changed, 371 insertions(+), 119 deletions(-) create mode 100644 tests/test_api_url.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 043f196..8ab435a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,8 @@ ### 2.0.0 / 2026-05-20 ### -* @TODO before merging: expand the SDK surface so this release supports all Transloadit API endpoints, and update these release notes with the final endpoint coverage. * **Breaking Change**: Raised the supported Python runtime floor from 3.9+ to 3.12+ so the SDK no longer has to retain vulnerable locked dependency versions for EOL Python 3.9 or depend on tooling lines that are already dropping older runtime support. +* Expanded low-level API endpoint coverage for Assemblies, Assembly Notifications, Templates, Template Credentials, Priority Job Slots, and Billing, with sync and async methods generated from the API2 endpoint contract. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. -* Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async polling rate-limit retries reset after successful polls, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. +* Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. * Raised the runtime HTTP stack to patched versions by requiring `requests` 2.33+ and adding an explicit `urllib3` 2.7+ floor. diff --git a/tests/test_api_url.py b/tests/test_api_url.py new file mode 100644 index 0000000..e37e7fe --- /dev/null +++ b/tests/test_api_url.py @@ -0,0 +1,14 @@ +import unittest + +from transloadit.api_url import should_sign_api_url + + +class ApiUrlTest(unittest.TestCase): + def test_should_sign_same_service_url_with_different_host_casing(self): + self.assertTrue( + should_sign_api_url( + "https://API2.transloadit.com/assemblies/abc", + "https://api2.transloadit.com", + ) + ) + diff --git a/tests/test_assembly.py b/tests/test_assembly.py index 0a034ae..a65b365 100644 --- a/tests/test_assembly.py +++ b/tests/test_assembly.py @@ -130,3 +130,208 @@ def test_save_resumable_retries_rate_limit_before_tus_upload(self): "https://api2.example/assemblies/abc", ) uploader.upload.assert_called_once() + + def test_save_non_resumable_rewinds_seekable_files_before_retry(self): + upload = io.BytesIO(b"payload") + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + success = Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "abcdef45673"}, + status_code=200, + headers={}, + ) + seen_positions = [] + self.assembly.add_file(upload, "payload_field") + + def post_side_effect(*args, **kwargs): + seen_positions.append(kwargs["files"]["payload_field"].tell()) + kwargs["files"]["payload_field"].seek(0, io.SEEK_END) + return rate_limited if len(seen_positions) == 1 else success + + with mock.patch.object(self.transloadit.request, "post", side_effect=post_side_effect): + with mock.patch("transloadit.assembly.sleep"): + assembly = self.assembly.create(resumable=False, retries=1) + + self.assertEqual(assembly.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual(seen_positions, [0, 0]) + + def test_save_non_resumable_rejects_non_seekable_file_retry(self): + class NonSeekableFile: + pass + + rate_limited = Response( + data={ + "error": "RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + self.assembly.add_file(NonSeekableFile(), "payload_field") + + with mock.patch.object(self.transloadit.request, "post", return_value=rate_limited): + with self.assertRaises(RuntimeError): + self.assembly.create(resumable=False, retries=1) + + def test_save_wait_raises_on_plain_text_create_response(self): + plain_response = Response( + data="plain assembly response", + status_code=502, + headers={"X-Route": "plain"}, + ) + + with mock.patch.object(self.transloadit.request, "post", return_value=plain_response): + with self.assertRaises(RuntimeError): + self.assembly.create(wait=True, resumable=False) + + def test_save_returns_plain_text_success_without_wait(self): + plain_response = Response( + data="plain assembly response", + status_code=200, + headers={"X-Route": "plain"}, + ) + + with mock.patch.object(self.transloadit.request, "post", return_value=plain_response): + response = self.assembly.create(wait=False, resumable=False) + + self.assertIs(response, plain_response) + + def test_save_resumable_plain_text_response_raises_before_tus_upload(self): + plain_response = Response( + data="plain assembly response", + status_code=200, + headers={"X-Route": "plain"}, + ) + self.assembly.add_file(io.BytesIO(b"payload"), "payload_field") + + with mock.patch.object(self.transloadit.request, "post", return_value=plain_response): + with mock.patch("transloadit.assembly.tus.TusClient") as tus_client: + with self.assertRaises(RuntimeError): + self.assembly.create(resumable=True) + + tus_client.assert_not_called() + + def test_save_wait_pins_assembly_url_across_poll_rate_limits(self): + initial_response = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": "https://api2.example/assemblies/abc", + }, + status_code=200, + headers={}, + ) + rate_limited = Response( + data={ + "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + completed = Response( + data={ + "ok": "ASSEMBLY_COMPLETED", + "assembly_ssl_url": "https://api2.example/assemblies/other", + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(self.transloadit.request, "post", return_value=initial_response): + with mock.patch.object( + self.transloadit, + "get_assembly", + side_effect=[rate_limited, completed], + ) as get_mock: + with mock.patch("transloadit.assembly.sleep"): + response = self.assembly.create(wait=True, resumable=False, retries=2) + + self.assertIs(response, completed) + self.assertEqual( + get_mock.call_args_list, + [ + mock.call(assembly_url="https://api2.example/assemblies/abc"), + mock.call(assembly_url="https://api2.example/assemblies/abc"), + ], + ) + + def test_save_wait_does_not_follow_poll_response_assembly_url(self): + initial_response = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": "https://api2.example/assemblies/abc", + }, + status_code=200, + headers={}, + ) + redirected_processing = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": "https://example.invalid/assemblies/evil", + }, + status_code=200, + headers={}, + ) + completed = Response( + data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "abcdef45673"}, + status_code=200, + headers={}, + ) + + with mock.patch.object(self.transloadit.request, "post", return_value=initial_response): + with mock.patch.object( + self.transloadit, + "get_assembly", + side_effect=[redirected_processing, completed], + ) as get_mock: + with mock.patch("transloadit.assembly.sleep"): + response = self.assembly.create(wait=True, resumable=False, retries=2) + + self.assertIs(response, completed) + self.assertEqual( + get_mock.call_args_list, + [ + mock.call(assembly_url="https://api2.example/assemblies/abc"), + mock.call(assembly_url="https://api2.example/assemblies/abc"), + ], + ) + + def test_save_wait_caps_poll_rate_limit_retries(self): + initial_response = Response( + data={ + "ok": "ASSEMBLY_PROCESSING", + "info": {"retryIn": 0}, + "assembly_ssl_url": "https://api2.example/assemblies/abc", + }, + status_code=200, + headers={}, + ) + rate_limited = Response( + data={ + "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + "info": {"retryIn": 0}, + }, + status_code=200, + headers={}, + ) + + with mock.patch.object(self.transloadit.request, "post", return_value=initial_response): + with mock.patch.object( + self.transloadit, + "get_assembly", + return_value=rate_limited, + ) as get_mock: + with mock.patch("transloadit.assembly.sleep"): + response = self.assembly.create(wait=True, resumable=False, retries=1) + + self.assertIs(response, rate_limited) + self.assertEqual(get_mock.call_count, 2) diff --git a/transloadit/api_url.py b/transloadit/api_url.py index 192062d..9cae650 100644 --- a/transloadit/api_url.py +++ b/transloadit/api_url.py @@ -36,11 +36,12 @@ def should_sign_api_url(url, service): # Only same-service URLs and Transloadit API regional hosts may receive auth params. if ( parsed_url.scheme == parsed_service.scheme - and parsed_url.netloc == parsed_service.netloc + and (parsed_url.hostname or "").lower() == (parsed_service.hostname or "").lower() + and parsed_url.port == parsed_service.port ): return True - hostname = parsed_url.hostname or "" + hostname = (parsed_url.hostname or "").lower() return parsed_url.scheme == "https" and ( hostname == "api2.transloadit.com" or (hostname.startswith("api2-") and hostname.endswith(".transloadit.com")) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 3aecb72..80b1ff0 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -1,3 +1,4 @@ +import math from time import sleep from tusclient import client as tus @@ -64,14 +65,36 @@ def remove_file(self, field_name): """ self.files.pop(field_name) + def _snapshot_file_positions(self): + positions = {} + missing = [] + for key, file_stream in self.files.items(): + try: + positions[key] = file_stream.tell() + except (AttributeError, OSError, ValueError): + missing.append(key) + return positions, missing + + def _rewind_files(self, positions): + for key, position in positions.items(): + file_stream = self.files.get(key) + if file_stream is None: + continue + try: + file_stream.seek(position) + except (AttributeError, OSError, ValueError) as exc: + raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc + def _do_tus_upload(self, assembly_url, tus_url, retries): tus_client = tus.TusClient(tus_url) - metadata = {"assembly_url": assembly_url} - for key in self.files: - metadata["fieldname"] = key - metadata["filename"] = get_upload_filename(self.files[key], key) + for key, file_stream in self.files.items(): + metadata = { + "assembly_url": assembly_url, + "fieldname": key, + "filename": get_upload_filename(file_stream, key), + } tus_client.uploader( - file_stream=self.files[key], + file_stream=file_stream, chunk_size=5 * 1024 * 1024, metadata=metadata, retries=retries, @@ -91,58 +114,117 @@ def create(self, wait=False, resumable=True, retries=3): available if 'resumable' is set to 'True'. Defaults to 3 if not specified. """ data = self.get_options() - if resumable: - extra_data = {"tus_num_expected_upload_files": len(self.files)} - response = self.transloadit.request.post( - "/assemblies", extra_data=extra_data, data=data - ) - else: - response = self.transloadit.request.post( - "/assemblies", data=data, files=self.files - ) - - if self._rate_limit_reached(response) and retries: - # wait till rate limit is expired - sleep(response.data.get("info", {}).get("retryIn", 1)) - return self.create(wait, resumable, retries - 1) - - if resumable and isinstance(response.data, dict): - if response.data.get("error") is not None: + file_positions, missing_file_positions = self._snapshot_file_positions() + tus_retries = retries + poll_retries = retries + + while True: + if resumable: + extra_data = {"tus_num_expected_upload_files": len(self.files)} + response = self.transloadit.request.post( + "/assemblies", extra_data=extra_data, data=data + ) + else: + response = self.transloadit.request.post( + "/assemblies", data=data, files=self.files + ) + + response_data = self._response_data(response) + if response_data is None: + if response.status_code >= 400 or wait or (resumable and self.files): + raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") return response - if self.files: - assembly_url = response.data.get("assembly_ssl_url") - tus_url = response.data.get("tus_url") + + if self._rate_limit_reached(response_data): + if retries: + if not resumable and missing_file_positions: + missing = ", ".join(repr(key) for key in missing_file_positions) + raise RuntimeError( + "Cannot retry non-resumable upload because these file streams are not seekable: " + f"{missing}" + ) + if not resumable: + self._rewind_files(file_positions) + sleep(self._retry_delay(response_data)) + retries -= 1 + continue + return response + + error = response_data.get("error") + assembly_url = response_data.get("assembly_ssl_url") + tus_url = response_data.get("tus_url") + + if error is not None: + return response + + if resumable and self.files: if not assembly_url or not tus_url: raise RuntimeError( - f"Resumable assembly response is missing upload URLs: {response.data!r}" + f"Resumable assembly response is missing upload URLs: {response_data!r}" ) - self._do_tus_upload(assembly_url, tus_url, retries) - - if wait: - while not self._assembly_finished(response): - # if a wait period is provided by the API due to polling - # rate limit, we should use that period, otherwise, we - # will fallback to 1 second. - sleep_time = response.data.get("info", {}).get("retryIn", 1) - sleep(sleep_time) - response = self.transloadit.get_assembly( - assembly_url=response.data.get("assembly_ssl_url") - ) - - return response - - def _assembly_finished(self, response): - status = response.data.get("ok") + self._do_tus_upload(assembly_url, tus_url, tus_retries) + + if wait: + if not assembly_url: + return response + + poll_response = response + poll_data = response_data + remaining_rate_limit_retries = poll_retries + while not self._assembly_finished(poll_data): + if self._rate_limit_reached(poll_data): + if remaining_rate_limit_retries <= 0: + return poll_response + remaining_rate_limit_retries -= 1 + else: + remaining_rate_limit_retries = poll_retries + sleep(self._retry_delay(poll_data)) + poll_response = self.transloadit.get_assembly(assembly_url=assembly_url) + poll_data = self._response_data(poll_response) + if poll_data is None: + raise RuntimeError( + f"Unexpected non-JSON response ({poll_response.status_code})." + ) + + return poll_response + + return response + + def _response_data(self, response): + data = response.data + return data if isinstance(data, dict) else None + + def _assembly_finished(self, response_data): + status = response_data.get("ok") is_aborted = status == "REQUEST_ABORTED" is_canceled = status == "ASSEMBLY_CANCELED" is_completed = status == "ASSEMBLY_COMPLETED" - error = response.data.get("error") + error = response_data.get("error") is_failed = error is not None is_fetch_rate_limit = error == "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED" - return is_aborted or is_canceled or is_completed or (is_failed and not is_fetch_rate_limit) - - def _rate_limit_reached(self, response): + is_submit_rate_limit = error == "RATE_LIMIT_REACHED" return ( - isinstance(response.data, dict) - and response.data.get("error") == "RATE_LIMIT_REACHED" + is_aborted + or is_canceled + or is_completed + or (is_failed and not (is_fetch_rate_limit or is_submit_rate_limit)) ) + + def _rate_limit_reached(self, response_data): + error = response_data.get("error") + return isinstance(error, str) and error in { + "RATE_LIMIT_REACHED", + "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", + } + + def _retry_delay(self, response_data): + info = response_data.get("info") + if not isinstance(info, dict): + return 1 + try: + delay = float(info.get("retryIn", 1)) + except (TypeError, ValueError): + return 1 + if not math.isfinite(delay): + return 1 + return max(delay, 0) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 4693415..09cb3dd 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -65,7 +65,7 @@ async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Get the assembly specified by the 'assembly_id' or the 'assembly_url'. + Retrieve an Assembly Status. """ if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") @@ -75,13 +75,13 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): async def list_assemblies(self, params: dict = None): """ - Get the list of assemblies. + Retrieve list of Assemblies. """ return await self.request.get("/assemblies", params=params) async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Cancel the assembly specified by the 'assembly_id' or the 'assembly_url'. + Cancel a running Assembly. """ if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") @@ -115,7 +115,7 @@ async def list_assembly_notifications(self, assembly_id: str): async def get_template(self, template_id: str): """ - Get the template specified by the 'template_id'. + Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") @@ -146,7 +146,7 @@ async def get_builtin_template_full(self, builtin_template_slug: str): async def list_templates(self, params: Optional[dict] = None): """ - Get the list of templates. + Retrieve list of Templates. """ return await self.request.get("/templates", params=params) @@ -158,14 +158,14 @@ async def create_template(self, data: Optional[dict] = None): async def update_template(self, template_id: str, data: dict): """ - Update the template specified by the 'template_id'. + Edit a Template. """ template_id = require_path_id(template_id, "template_id") return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) async def delete_template(self, template_id: str): """ - Delete the template specified by the 'template_id'. + Delete a Template. """ template_id = require_path_id(template_id, "template_id") return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") @@ -226,7 +226,7 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict async def get_bill(self, month: int, year: int): """ - Get the bill for the specified month and year. + Retrieve a month’s bill. """ return await self.request.get(f"/bill/{year}-{month:02d}") diff --git a/transloadit/client.py b/transloadit/client.py index 287f316..62e38d2 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -73,14 +73,7 @@ def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Get the assembly specified by the 'assembly_id' or the 'assembly_url' - Either the assembly_id or the assembly_url must be specified - - :Args: - - assembly_id (Optional[str]) - - assembly_url (Optional[str]) - - Return an instance of + Retrieve an Assembly Status. """ if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") @@ -90,27 +83,13 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None): def list_assemblies(self, params: dict = None): """ - Get the list of assemblies. - - :Args: - - options (Optional[dict]): - params to send along with the request. Please see - https://transloadit.com/docs/api-docs/#25-retrieve-assembly-list for available options. - - Return an instance of + Retrieve list of Assemblies. """ return self.request.get("/assemblies", params=params) def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Cancel the assembly specified by the 'assembly_id' or the 'assembly_url' - Either the assembly_id or the assembly_url must be specified - - :Args: - - assembly_id (Optional[str]) - - assembly_url (Optional[str]) - - Return an instance of + Cancel a running Assembly. """ if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") @@ -144,12 +123,7 @@ def list_assembly_notifications(self, assembly_id: str): def get_template(self, template_id: str): """ - Get the template specified by the 'template_id'. - - :Args: - - template_id (str) - - Return an instance of + Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") return self.request.get(f"/templates/{_quote_path_segment(template_id)}") @@ -180,14 +154,7 @@ def get_builtin_template_full(self, builtin_template_slug: str): def list_templates(self, params: Optional[dict] = None): """ - Get the list of templates. - - :Args: - - options (Optional[dict]): - params to send along with the request. Please see - https://transloadit.com/docs/api-docs/#45-retrieve-template-list for available options. - - Return an instance of + Retrieve list of Templates. """ return self.request.get("/templates", params=params) @@ -199,25 +166,14 @@ def create_template(self, data: Optional[dict] = None): def update_template(self, template_id: str, data: dict): """ - Update the template specified by the 'template_id'. - - :Args: - - template_id (str) - - data (dict): key, value pair of fields and their new values. - - Return an instance of + Edit a Template. """ template_id = require_path_id(template_id, "template_id") return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) def delete_template(self, template_id: str): """ - Delete the template specified by the 'template_id'. - - :Args: - - template_id (str) - - Return an instance of + Delete a Template. """ template_id = require_path_id(template_id, "template_id") return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") @@ -278,13 +234,7 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No def get_bill(self, month: int, year: int): """ - Get the bill for the specified month and year. - - :Args: - - month (int): e.g 1 for January - - year (int) - - Return an instance of + Retrieve a month’s bill. """ return self.request.get(f"/bill/{year}-{month:02d}") From 0c4c9747e0d70c92ddf34fce5a9d7b42d145579a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 24 May 2026 14:50:02 +0200 Subject: [PATCH 26/64] Regenerate endpoint methods from API2 contracts --- transloadit/async_client.py | 53 ++++++++++++++++++++----------------- transloadit/client.py | 53 ++++++++++++++++++++----------------- 2 files changed, 56 insertions(+), 50 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 09cb3dd..8c2f1dd 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -63,6 +63,12 @@ async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = return await self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + async def list_assemblies(self, params: Optional[dict] = None): + """ + Retrieve list of Assemblies. + """ + return await self.request.get("/assemblies", params=params) + async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Retrieve an Assembly Status. @@ -73,12 +79,6 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return await self.request.get(url) - async def list_assemblies(self, params: dict = None): - """ - Retrieve list of Assemblies. - """ - return await self.request.get("/assemblies", params=params) - async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Cancel a running Assembly. @@ -113,11 +113,30 @@ async def list_assembly_notifications(self, assembly_id: str): return await self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + async def get_bill(self, month: int, year: int): + """ + Retrieve a month’s bill. + """ + return await self.request.get(f"/bill/{year}-{month:02d}") + + async def list_templates(self, params: Optional[dict] = None): + """ + Retrieve list of Templates. + """ + return await self.request.get("/templates", params=params) + + async def create_template(self, data: Optional[dict] = None): + """ + Create a new Template. + """ + return await self.request.post("/templates", data=data) + async def get_template(self, template_id: str): """ Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") + return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") async def get_builtin_template(self, builtin_template_slug: str): @@ -144,23 +163,12 @@ async def get_builtin_template_full(self, builtin_template_slug: str): return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") - async def list_templates(self, params: Optional[dict] = None): - """ - Retrieve list of Templates. - """ - return await self.request.get("/templates", params=params) - - async def create_template(self, data: Optional[dict] = None): - """ - Create a new Template. - """ - return await self.request.post("/templates", data=data) - - async def update_template(self, template_id: str, data: dict): + async def update_template(self, template_id: str, data: Optional[dict] = None): """ Edit a Template. """ template_id = require_path_id(template_id, "template_id") + return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) async def delete_template(self, template_id: str): @@ -168,6 +176,7 @@ async def delete_template(self, template_id: str): Delete a Template. """ template_id = require_path_id(template_id, "template_id") + return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") async def list_priority_job_slots(self): @@ -224,12 +233,6 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict return await self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) - async def get_bill(self, month: int, year: int): - """ - Retrieve a month’s bill. - """ - return await self.request.get(f"/bill/{year}-{month:02d}") - # def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: diff --git a/transloadit/client.py b/transloadit/client.py index 62e38d2..c70b7fe 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -71,6 +71,12 @@ def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, return self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + def list_assemblies(self, params: Optional[dict] = None): + """ + Retrieve list of Assemblies. + """ + return self.request.get("/assemblies", params=params) + def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Retrieve an Assembly Status. @@ -81,12 +87,6 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None): url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" return self.request.get(url) - def list_assemblies(self, params: dict = None): - """ - Retrieve list of Assemblies. - """ - return self.request.get("/assemblies", params=params) - def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ Cancel a running Assembly. @@ -121,11 +121,30 @@ def list_assembly_notifications(self, assembly_id: str): return self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + def get_bill(self, month: int, year: int): + """ + Retrieve a month’s bill. + """ + return self.request.get(f"/bill/{year}-{month:02d}") + + def list_templates(self, params: Optional[dict] = None): + """ + Retrieve list of Templates. + """ + return self.request.get("/templates", params=params) + + def create_template(self, data: Optional[dict] = None): + """ + Create a new Template. + """ + return self.request.post("/templates", data=data) + def get_template(self, template_id: str): """ Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") + return self.request.get(f"/templates/{_quote_path_segment(template_id)}") def get_builtin_template(self, builtin_template_slug: str): @@ -152,23 +171,12 @@ def get_builtin_template_full(self, builtin_template_slug: str): return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") - def list_templates(self, params: Optional[dict] = None): - """ - Retrieve list of Templates. - """ - return self.request.get("/templates", params=params) - - def create_template(self, data: Optional[dict] = None): - """ - Create a new Template. - """ - return self.request.post("/templates", data=data) - - def update_template(self, template_id: str, data: dict): + def update_template(self, template_id: str, data: Optional[dict] = None): """ Edit a Template. """ template_id = require_path_id(template_id, "template_id") + return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) def delete_template(self, template_id: str): @@ -176,6 +184,7 @@ def delete_template(self, template_id: str): Delete a Template. """ template_id = require_path_id(template_id, "template_id") + return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") def list_priority_job_slots(self): @@ -232,12 +241,6 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No return self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) - def get_bill(self, month: int, year: int): - """ - Retrieve a month’s bill. - """ - return self.request.get(f"/bill/{year}-{month:02d}") - # def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: From 43e999eb603dad44750bbbe54e46505fbdd1bc27 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Mon, 25 May 2026 22:21:48 +0200 Subject: [PATCH 27/64] Harden async SDK edge cases --- tests/test_api_url.py | 7 +++++++ tests/test_async_client.py | 2 +- tests/test_response.py | 15 ++++++++++++++- tests/test_template.py | 15 +++++++++++++++ transloadit/api_url.py | 15 ++++++++++++--- transloadit/assembly.py | 4 +--- transloadit/async_assembly.py | 4 +--- transloadit/async_template.py | 5 ++++- transloadit/response.py | 5 ++++- transloadit/template.py | 5 ++++- 10 files changed, 63 insertions(+), 14 deletions(-) diff --git a/tests/test_api_url.py b/tests/test_api_url.py index e37e7fe..6ee85f2 100644 --- a/tests/test_api_url.py +++ b/tests/test_api_url.py @@ -12,3 +12,10 @@ def test_should_sign_same_service_url_with_different_host_casing(self): ) ) + def test_should_not_sign_transloadit_url_for_custom_service(self): + self.assertFalse( + should_sign_api_url( + "https://api2-freja.transloadit.com/assemblies/abc", + "https://uploads.example.test", + ) + ) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index d989718..6ea6ae9 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -1179,7 +1179,7 @@ def uploader(self, **kwargs): with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock: with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - with self.assertRaisesRegex(RuntimeError, "ASSEMBLY_PROCESSING"): + with self.assertRaisesRegex(RuntimeError, "missing upload URLs"): await assembly.create(resumable=True) post_mock.assert_awaited_once() diff --git a/tests/test_response.py b/tests/test_response.py index c5b28d3..b58a13c 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -24,7 +24,8 @@ def test_response_data_is_assignable_and_eager_for_sync_responses(self): def test_response_uses_text_fallback_for_sync_non_json_responses(self): raw = mock.Mock() raw.json.side_effect = ValueError("not json") - raw.text = "bad gateway" + raw.content = b"bad gateway" + raw.encoding = "utf-8" raw.status_code = 502 raw.headers = {"Content-Type": "text/html"} @@ -33,6 +34,18 @@ def test_response_uses_text_fallback_for_sync_non_json_responses(self): self.assertEqual(response.data, "bad gateway") self.assertEqual(response.status_code, 502) + def test_response_uses_bytes_fallback_for_undecodable_sync_non_json_responses(self): + raw = mock.Mock() + raw.json.side_effect = ValueError("not json") + raw.content = b"\xff\xfe" + raw.encoding = "utf-8" + raw.status_code = 200 + raw.headers = {"Content-Type": "application/octet-stream"} + + response = Response(raw) + + self.assertEqual(response.data, b"\xff\xfe") + def test_response_lazily_rehydrates_data_when_missing(self): raw = mock.Mock() raw.json.return_value = {"ok": "lazy"} diff --git a/tests/test_template.py b/tests/test_template.py index 3db4b62..415ba11 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -1,5 +1,6 @@ import unittest import urllib.parse +from unittest import mock import requests_mock @@ -29,3 +30,17 @@ def test_save(self, mock): template = self.template.create() self.assertEqual(template.data["ok"], "TEMPLATE_CREATED") self.assertEqual(template.data["template_name"], "foo") + + def test_create_preserves_string_template_payload(self): + template = self.transloadit.new_template( + "foo", + params={"template": '{"steps":{}}'}, + ) + + with mock.patch.object(self.transloadit.request, "post") as post_mock: + template.create() + + post_mock.assert_called_once_with( + "/templates", + data={"name": "foo", "template": '{"steps":{}}'}, + ) diff --git a/transloadit/api_url.py b/transloadit/api_url.py index 9cae650..f952a76 100644 --- a/transloadit/api_url.py +++ b/transloadit/api_url.py @@ -41,8 +41,17 @@ def should_sign_api_url(url, service): ): return True + service_hostname = (parsed_service.hostname or "").lower() + service_is_transloadit_api = service_hostname == "api2.transloadit.com" or ( + service_hostname.startswith("api2-") + and service_hostname.endswith(".transloadit.com") + ) hostname = (parsed_url.hostname or "").lower() - return parsed_url.scheme == "https" and ( - hostname == "api2.transloadit.com" - or (hostname.startswith("api2-") and hostname.endswith(".transloadit.com")) + url_is_transloadit_api = hostname == "api2.transloadit.com" or ( + hostname.startswith("api2-") and hostname.endswith(".transloadit.com") + ) + return ( + service_is_transloadit_api + and parsed_url.scheme == "https" + and url_is_transloadit_api ) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 80b1ff0..09e8db7 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -159,9 +159,7 @@ def create(self, wait=False, resumable=True, retries=3): if resumable and self.files: if not assembly_url or not tus_url: - raise RuntimeError( - f"Resumable assembly response is missing upload URLs: {response_data!r}" - ) + raise RuntimeError("Resumable assembly response is missing upload URLs.") self._do_tus_upload(assembly_url, tus_url, tus_retries) if wait: diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 18ac00a..64a9c4b 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -144,9 +144,7 @@ async def create(self, wait=False, resumable=True, retries=3): if resumable and self.files: if not assembly_url or not tus_url: - raise RuntimeError( - f"Resumable assembly response is missing upload URLs: {response_data!r}" - ) + raise RuntimeError("Resumable assembly response is missing upload URLs.") await self._do_tus_upload_async(assembly_url, tus_url, tus_retries) if wait: diff --git a/transloadit/async_template.py b/transloadit/async_template.py index 4925994..d76688e 100644 --- a/transloadit/async_template.py +++ b/transloadit/async_template.py @@ -17,8 +17,11 @@ async def create(self): """ data = self.get_options() steps = data.pop("steps") - template_content = dict(data.pop("template", {}) or {}) + template = data.pop("template", None) + template_content = dict(template) if isinstance(template, dict) else template or {} if steps: + if not isinstance(template_content, dict): + raise ValueError("template must be an object when steps are supplied.") template_content["steps"] = steps data.update({"name": self.name, "template": template_content}) return await self.transloadit.request.post("/templates", data=data) diff --git a/transloadit/response.py b/transloadit/response.py index 51b08f8..33d25d3 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -37,7 +37,10 @@ def _read_sync_response_data(self): return self._response.json() except ValueError: try: - return self._response.text + return self._response.content.decode( + self._response.encoding or "utf-8", + errors="strict", + ) except UnicodeDecodeError: return self._response.content diff --git a/transloadit/template.py b/transloadit/template.py index 90b458f..69eb8e6 100644 --- a/transloadit/template.py +++ b/transloadit/template.py @@ -30,8 +30,11 @@ def create(self): """ data = self.get_options() steps = data.pop("steps") - template_content = dict(data.pop("template", {}) or {}) + template = data.pop("template", None) + template_content = dict(template) if isinstance(template, dict) else template or {} if steps: + if not isinstance(template_content, dict): + raise ValueError("template must be an object when steps are supplied.") template_content["steps"] = steps data.update({"name": self.name, "template": template_content}) return self.transloadit.request.post("/templates", data=data) From d80ba1432ff13daedec40135958fc23442b9b42b Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 26 May 2026 09:21:38 +0200 Subject: [PATCH 28/64] Mark generated blocks as contract-owned --- transloadit/async_client.py | 4 ++++ transloadit/client.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 8c2f1dd..38df0b7 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -49,6 +49,10 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: return async_assembly.AsyncAssembly(self, options=params) # + # This block is generated from Transloadit API2 contracts. If it looks wrong, + # please report the issue instead of editing this block by hand; the source fix + # belongs in the contract generator so all SDKs stay in sync. + async def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. diff --git a/transloadit/client.py b/transloadit/client.py index c70b7fe..7743c34 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -57,6 +57,10 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: return assembly.Assembly(self, options=params) # + # This block is generated from Transloadit API2 contracts. If it looks wrong, + # please report the issue instead of editing this block by hand; the source fix + # belongs in the contract generator so all SDKs stay in sync. + def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. From 7341ccf5bd429c2f7ff6abf0f3c3411899ece871 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 26 May 2026 09:33:47 +0200 Subject: [PATCH 29/64] Add generated wait for assembly helpers --- tests/test_async_client.py | 43 +++++++++++++++++++++++++++++++++++++ tests/test_client.py | 33 ++++++++++++++++++++++++++++ transloadit/async_client.py | 30 ++++++++++++++++++++++++++ transloadit/client.py | 30 ++++++++++++++++++++++++++ 4 files changed, 136 insertions(+) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 6ea6ae9..4f8836f 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -752,6 +752,49 @@ async def test_async_assembly_wait_raises_on_plain_text_success_poll_response(se ) sleep_mock.assert_awaited_once_with(0) + async def test_async_wait_for_assembly_polls_until_terminal(self): + responses = [ + Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), + Response(data={"ok": "ASSEMBLY_EXECUTING"}, status_code=200), + Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200), + ] + assembly_url = f"{self.server.base_url}/assemblies/assembly-123" + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(side_effect=responses), + ) as get_mock: + with mock.patch( + "transloadit.async_client.asyncio.sleep", + new_callable=mock.AsyncMock, + ) as sleep_mock: + response = await client.wait_for_assembly(assembly_url) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual( + get_mock.await_args_list, + [ + mock.call(assembly_url=assembly_url), + mock.call(assembly_url=assembly_url), + mock.call(assembly_url=assembly_url), + ], + ) + self.assertEqual(sleep_mock.await_args_list, [mock.call(1), mock.call(1)]) + + async def test_async_wait_for_assembly_rejects_non_json_poll_response(self): + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + with mock.patch.object( + client, + "get_assembly", + new=mock.AsyncMock(return_value=Response(data="plain response", status_code=502)), + ): + with self.assertRaises(RuntimeError): + await client.wait_for_assembly( + f"{self.server.base_url}/assemblies/assembly-123" + ) + def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") diff --git a/tests/test_client.py b/tests/test_client.py index ad4cf43..3f9bbfd 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -11,6 +11,7 @@ from . import request_body_matcher from transloadit.client import Transloadit +from transloadit.response import Response def get_expected_url(params): @@ -77,6 +78,38 @@ def test_get_assembly(self, mock): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abcdef12345") + def test_wait_for_assembly_polls_until_terminal(self): + responses = [ + Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), + Response(data={"ok": "ASSEMBLY_EXECUTING"}, status_code=200), + Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200), + ] + assembly_url = "https://api2.example/assemblies/assembly-123" + + with mock.patch.object(self.transloadit, "get_assembly", side_effect=responses) as get_mock: + with mock.patch("transloadit.client.sleep") as sleep_mock: + response = self.transloadit.wait_for_assembly(assembly_url) + + self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") + self.assertEqual( + get_mock.call_args_list, + [ + mock.call(assembly_url=assembly_url), + mock.call(assembly_url=assembly_url), + mock.call(assembly_url=assembly_url), + ], + ) + self.assertEqual(sleep_mock.call_args_list, [mock.call(1), mock.call(1)]) + + def test_wait_for_assembly_rejects_non_json_poll_response(self): + with mock.patch.object( + self.transloadit, + "get_assembly", + return_value=Response(data="plain response", status_code=502), + ): + with self.assertRaises(RuntimeError): + self.transloadit.wait_for_assembly("https://api2.example/assemblies/assembly-123") + def test_quotes_path_ids(self): with mock.patch.object(self.transloadit.request, 'get') as get_mock: self.transloadit.get_assembly(assembly_id='assembly/with?chars') diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 38df0b7..e2d6716 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -1,3 +1,4 @@ +import asyncio from typing import Optional from urllib.parse import quote @@ -239,6 +240,35 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict # + # + # This block is generated from Transloadit API2 contracts. If it looks wrong, + # please report the issue instead of editing this block by hand; the source fix + # belongs in the contract generator so all SDKs stay in sync. + + async def wait_for_assembly(self, assembly_url: str): + """ + Wait for an Assembly to finish uploading and executing. + The assembly URL should be the assembly_ssl_url returned by create_assembly. + """ + while True: + response = await self.get_assembly(assembly_url=assembly_url) + data = response.data + + if not isinstance(data, dict): + raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") + + # Abort polling if the assembly has entered an error state + if data.get("error"): + return response + + # The polling is done if the assembly is not uploading or executing anymore. + if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING"): + return response + + await asyncio.sleep(1) + + # + def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: """ Return an instance of . diff --git a/transloadit/client.py b/transloadit/client.py index 7743c34..7b4dc80 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -1,4 +1,5 @@ import typing +from time import sleep from typing import Optional from urllib.parse import quote @@ -247,6 +248,35 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No # + # + # This block is generated from Transloadit API2 contracts. If it looks wrong, + # please report the issue instead of editing this block by hand; the source fix + # belongs in the contract generator so all SDKs stay in sync. + + def wait_for_assembly(self, assembly_url: str): + """ + Wait for an Assembly to finish uploading and executing. + The assembly URL should be the assembly_ssl_url returned by create_assembly. + """ + while True: + response = self.get_assembly(assembly_url=assembly_url) + data = response.data + + if not isinstance(data, dict): + raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") + + # Abort polling if the assembly has entered an error state + if data.get("error"): + return response + + # The polling is done if the assembly is not uploading or executing anymore. + if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING"): + return response + + sleep(1) + + # + def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: """ Return an instance of which would be used to create From 24738def55e56d4e20e3079fc2d0bd9584604cc4 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Mon, 1 Jun 2026 17:35:41 +0200 Subject: [PATCH 30/64] Regenerate endpoint params --- tests/test_async_client.py | 18 +++++++------- tests/test_client.py | 20 ++++++++-------- transloadit/async_client.py | 48 ++++++++++++++++++------------------- transloadit/client.py | 48 ++++++++++++++++++------------------- 4 files changed, 68 insertions(+), 66 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 4f8836f..eab8489 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -528,19 +528,21 @@ async def test_async_generated_endpoint_methods_call_request_helpers(self): get_mock.await_args_list, [ mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), - mock.call("/templates/builtin/builtin%2Fwith%3Fchars"), - mock.call("/templates/template%2Fwith%3Fchars/full"), - mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full"), - mock.call("/queues/job_slots"), - mock.call("/template_credentials"), - mock.call("/template_credentials/types"), - mock.call("/template_credentials/cred%2Fwith%3Fchars"), + mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), + mock.call("/templates/template%2Fwith%3Fchars/full", params=None), + mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), + mock.call("/queues/job_slots", params=None), + mock.call("/template_credentials", params=None), + mock.call("/template_credentials/types", params=None), + mock.call("/template_credentials/cred%2Fwith%3Fchars", params=None), ], ) put_mock.assert_awaited_once_with( "/template_credentials/cred%2Fwith%3Fchars", data=credential_data ) - delete_mock.assert_awaited_once_with("/template_credentials/cred%2Fwith%3Fchars") + delete_mock.assert_awaited_once_with( + "/template_credentials/cred%2Fwith%3Fchars", data=None + ) async def test_async_generated_endpoint_methods_reject_empty_path_ids(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) diff --git a/tests/test_client.py b/tests/test_client.py index 3f9bbfd..febc6ae 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -118,8 +118,8 @@ def test_quotes_path_ids(self): self.assertEqual( get_mock.call_args_list, [ - mock.call('/assemblies/assembly%2Fwith%3Fchars'), - mock.call('/templates/template%2Fwith%3Fchars'), + mock.call('/assemblies/assembly%2Fwith%3Fchars', params=None), + mock.call('/templates/template%2Fwith%3Fchars', params=None), ], ) @@ -206,19 +206,19 @@ def test_generated_endpoint_methods_call_request_helpers(self): get_mock.call_args_list, [ mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), - mock.call("/templates/builtin/builtin%2Fwith%3Fchars"), - mock.call("/templates/template%2Fwith%3Fchars/full"), - mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full"), - mock.call("/queues/job_slots"), - mock.call("/template_credentials"), - mock.call("/template_credentials/types"), - mock.call("/template_credentials/cred%2Fwith%3Fchars"), + mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), + mock.call("/templates/template%2Fwith%3Fchars/full", params=None), + mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), + mock.call("/queues/job_slots", params=None), + mock.call("/template_credentials", params=None), + mock.call("/template_credentials/types", params=None), + mock.call("/template_credentials/cred%2Fwith%3Fchars", params=None), ], ) put_mock.assert_called_once_with( "/template_credentials/cred%2Fwith%3Fchars", data=credential_data ) - delete_mock.assert_called_once_with("/template_credentials/cred%2Fwith%3Fchars") + delete_mock.assert_called_once_with("/template_credentials/cred%2Fwith%3Fchars", data=None) def test_generated_endpoint_methods_reject_empty_path_ids(self): methods = [ diff --git a/transloadit/async_client.py b/transloadit/async_client.py index e2d6716..78a76c8 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -74,7 +74,7 @@ async def list_assemblies(self, params: Optional[dict] = None): """ return await self.request.get("/assemblies", params=params) - async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): + async def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params: Optional[dict] = None): """ Retrieve an Assembly Status. """ @@ -82,7 +82,7 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return await self.request.get(url) + return await self.request.get(url, params=params) async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ @@ -118,11 +118,11 @@ async def list_assembly_notifications(self, assembly_id: str): return await self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") - async def get_bill(self, month: int, year: int): + async def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ Retrieve a month’s bill. """ - return await self.request.get(f"/bill/{year}-{month:02d}") + return await self.request.get(f"/bill/{year}-{month:02d}", params=params) async def list_templates(self, params: Optional[dict] = None): """ @@ -136,37 +136,37 @@ async def create_template(self, data: Optional[dict] = None): """ return await self.request.post("/templates", data=data) - async def get_template(self, template_id: str): + async def get_template(self, template_id: str, params: Optional[dict] = None): """ Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") - return await self.request.get(f"/templates/{_quote_path_segment(template_id)}") + return await self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) - async def get_builtin_template(self, builtin_template_slug: str): + async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ Get Builtin Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}") + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) - async def get_template_full(self, template_id_or_name: str): + async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ Get Template Full. """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full") + return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) - async def get_builtin_template_full(self, builtin_template_slug: str): + async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ Get Builtin Template Full. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) async def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -176,31 +176,31 @@ async def update_template(self, template_id: str, data: Optional[dict] = None): return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) - async def delete_template(self, template_id: str): + async def delete_template(self, template_id: str, data: Optional[dict] = None): """ Delete a Template. """ template_id = require_path_id(template_id, "template_id") - return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}") + return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}", data=data) - async def list_priority_job_slots(self): + async def list_priority_job_slots(self, params: Optional[dict] = None): """ Retrieve currently used priority job slots. """ - return await self.request.get("/queues/job_slots") + return await self.request.get("/queues/job_slots", params=params) - async def list_template_credentials(self): + async def list_template_credentials(self, params: Optional[dict] = None): """ Retrieve list of Template Credentials. """ - return await self.request.get("/template_credentials") + return await self.request.get("/template_credentials", params=params) - async def list_template_credential_types(self): + async def list_template_credential_types(self, params: Optional[dict] = None): """ List Template Credential Types. """ - return await self.request.get("/template_credentials/types") + return await self.request.get("/template_credentials/types", params=params) async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): """ @@ -214,21 +214,21 @@ async def create_template_credentials(self, data: Optional[dict] = None): """ return await self.request.post("/template_credentials", data=data) - async def get_template_credentials(self, identifier: str): + async def get_template_credentials(self, identifier: str, params: Optional[dict] = None): """ Retrieve a Template Credential. """ identifier = require_path_id(identifier, "identifier") - return await self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}") + return await self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}", params=params) - async def delete_template_credentials(self, identifier: str): + async def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): """ Delete a Template Credential. """ identifier = require_path_id(identifier, "identifier") - return await self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}") + return await self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) async def update_template_credentials(self, identifier: str, data: Optional[dict] = None): """ diff --git a/transloadit/client.py b/transloadit/client.py index 7b4dc80..de88b0f 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -82,7 +82,7 @@ def list_assemblies(self, params: Optional[dict] = None): """ return self.request.get("/assemblies", params=params) - def get_assembly(self, assembly_id: str = None, assembly_url: str = None): + def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params: Optional[dict] = None): """ Retrieve an Assembly Status. """ @@ -90,7 +90,7 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return self.request.get(url) + return self.request.get(url, params=params) def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ @@ -126,11 +126,11 @@ def list_assembly_notifications(self, assembly_id: str): return self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") - def get_bill(self, month: int, year: int): + def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ Retrieve a month’s bill. """ - return self.request.get(f"/bill/{year}-{month:02d}") + return self.request.get(f"/bill/{year}-{month:02d}", params=params) def list_templates(self, params: Optional[dict] = None): """ @@ -144,37 +144,37 @@ def create_template(self, data: Optional[dict] = None): """ return self.request.post("/templates", data=data) - def get_template(self, template_id: str): + def get_template(self, template_id: str, params: Optional[dict] = None): """ Retrieve a Template. """ template_id = require_path_id(template_id, "template_id") - return self.request.get(f"/templates/{_quote_path_segment(template_id)}") + return self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) - def get_builtin_template(self, builtin_template_slug: str): + def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ Get Builtin Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}") + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) - def get_template_full(self, template_id_or_name: str): + def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ Get Template Full. """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full") + return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) - def get_builtin_template_full(self, builtin_template_slug: str): + def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ Get Builtin Template Full. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full") + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -184,31 +184,31 @@ def update_template(self, template_id: str, data: Optional[dict] = None): return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) - def delete_template(self, template_id: str): + def delete_template(self, template_id: str, data: Optional[dict] = None): """ Delete a Template. """ template_id = require_path_id(template_id, "template_id") - return self.request.delete(f"/templates/{_quote_path_segment(template_id)}") + return self.request.delete(f"/templates/{_quote_path_segment(template_id)}", data=data) - def list_priority_job_slots(self): + def list_priority_job_slots(self, params: Optional[dict] = None): """ Retrieve currently used priority job slots. """ - return self.request.get("/queues/job_slots") + return self.request.get("/queues/job_slots", params=params) - def list_template_credentials(self): + def list_template_credentials(self, params: Optional[dict] = None): """ Retrieve list of Template Credentials. """ - return self.request.get("/template_credentials") + return self.request.get("/template_credentials", params=params) - def list_template_credential_types(self): + def list_template_credential_types(self, params: Optional[dict] = None): """ List Template Credential Types. """ - return self.request.get("/template_credentials/types") + return self.request.get("/template_credentials/types", params=params) def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): """ @@ -222,21 +222,21 @@ def create_template_credentials(self, data: Optional[dict] = None): """ return self.request.post("/template_credentials", data=data) - def get_template_credentials(self, identifier: str): + def get_template_credentials(self, identifier: str, params: Optional[dict] = None): """ Retrieve a Template Credential. """ identifier = require_path_id(identifier, "identifier") - return self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}") + return self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}", params=params) - def delete_template_credentials(self, identifier: str): + def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): """ Delete a Template Credential. """ identifier = require_path_id(identifier, "identifier") - return self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}") + return self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) def update_template_credentials(self, identifier: str, data: Optional[dict] = None): """ From 70e8ba98913debf80ebd068df54e6bfd865d9139 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Mon, 1 Jun 2026 17:45:33 +0200 Subject: [PATCH 31/64] Generate TUS Assembly helper --- tests/test_async_client.py | 26 ++++++++++++++++++++++++++ tests/test_client.py | 23 +++++++++++++++++++++++ transloadit/async_client.py | 22 ++++++++++++++++++++++ transloadit/client.py | 22 ++++++++++++++++++++++ 4 files changed, 93 insertions(+) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index eab8489..cc59eea 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -797,6 +797,32 @@ async def test_async_wait_for_assembly_rejects_non_json_poll_response(self): f"{self.server.base_url}/assemblies/assembly-123" ) + async def test_async_create_tus_assembly_uses_contract_payload(self): + expected_response = Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200) + + async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: + with mock.patch.object( + client, + "create_assembly", + new=mock.AsyncMock(return_value=expected_response), + ) as create_mock: + response = await client.create_tus_assembly(2) + + self.assertIs(response, expected_response) + create_mock.assert_awaited_once_with( + data={ + "await": False, + "steps": { + ":original": { + "output_meta": True, + "result": "debug", + "robot": "/upload/handle", + }, + }, + }, + extra_data={"num_expected_upload_files": 2}, + ) + def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") diff --git a/tests/test_client.py b/tests/test_client.py index febc6ae..824fc97 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -110,6 +110,29 @@ def test_wait_for_assembly_rejects_non_json_poll_response(self): with self.assertRaises(RuntimeError): self.transloadit.wait_for_assembly("https://api2.example/assemblies/assembly-123") + def test_create_tus_assembly_uses_contract_payload(self): + expected_response = Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200) + + with mock.patch.object( + self.transloadit, "create_assembly", return_value=expected_response + ) as create_mock: + response = self.transloadit.create_tus_assembly(2) + + self.assertIs(response, expected_response) + create_mock.assert_called_once_with( + data={ + "await": False, + "steps": { + ":original": { + "output_meta": True, + "result": "debug", + "robot": "/upload/handle", + }, + }, + }, + extra_data={"num_expected_upload_files": 2}, + ) + def test_quotes_path_ids(self): with mock.patch.object(self.transloadit.request, 'get') as get_mock: self.transloadit.get_assembly(assembly_id='assembly/with?chars') diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 78a76c8..7e0e302 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -245,6 +245,28 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + async def create_tus_assembly(self, file_count: int): + """ + Create a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. + """ + assembly = await self.create_assembly( + data={ + "await": False, + "steps": { + ":original": { + "output_meta": True, + "result": "debug", + "robot": "/upload/handle", + }, + }, + }, + extra_data={ + "num_expected_upload_files": file_count, + }, + ) + + return assembly + async def wait_for_assembly(self, assembly_url: str): """ Wait for an Assembly to finish uploading and executing. diff --git a/transloadit/client.py b/transloadit/client.py index de88b0f..d0b0167 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -253,6 +253,28 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + def create_tus_assembly(self, file_count: int): + """ + Create a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. + """ + assembly = self.create_assembly( + data={ + "await": False, + "steps": { + ":original": { + "output_meta": True, + "result": "debug", + "robot": "/upload/handle", + }, + }, + }, + extra_data={ + "num_expected_upload_files": file_count, + }, + ) + + return assembly + def wait_for_assembly(self, assembly_url: str): """ Wait for an Assembly to finish uploading and executing. From 27aa93c5e6f55a52a05aa07d02028f3d917bbe6b Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Mon, 1 Jun 2026 21:38:12 +0200 Subject: [PATCH 32/64] Add devdock TUS Assembly example --- examples/README.md | 7 + examples/api2-devdock-tus-assembly/main.py | 203 +++++++++++++++++++++ tests/test_examples.py | 5 + 3 files changed, 215 insertions(+) create mode 100644 examples/api2-devdock-tus-assembly/main.py diff --git a/examples/README.md b/examples/README.md index 4253a14..22f49e4 100644 --- a/examples/README.md +++ b/examples/README.md @@ -26,6 +26,13 @@ Transloadit and may create temporary Assemblies or Templates in your account. These quickstart examples run in CI against a dedicated Transloadit test account, so they are kept in sync with the SDK and API. +## API2 Contract QA Examples + +`api2-devdock-*` examples are runnable usage examples that API2's contract QA runs +against devdock. They expect API2 to inject a scenario JSON file via +`API2_SDK_EXAMPLE_SCENARIO`, so the API/TUS facts stay in API2 contracts while the +example code remains normal SDK usage. + ## Advanced Examples These examples require pre-created Templates and, depending on your Template, third-party diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py new file mode 100644 index 0000000..92ae790 --- /dev/null +++ b/examples/api2-devdock-tus-assembly/main.py @@ -0,0 +1,203 @@ +"""Run the API2 contract TUS Assembly scenario against a devdock API2 server. + +This example is intentionally checked into the SDK repository: it should read +the API/TUS facts from API2's injected scenario JSON and exercise public SDK +methods as normal user code would. +""" + +import json +import os +from io import BytesIO +from pathlib import Path +from urllib.parse import quote + +from transloadit.client import Transloadit +from tusclient import client as tus + + +def required_env(name): + value = os.environ.get(name) + if not value: + raise RuntimeError(f"{name} must be set") + return value + + +def fail(message): + raise RuntimeError(message) + + +def load_scenario(): + configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") + scenario_path = ( + Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") + ) + with scenario_path.open(encoding="utf-8") as scenario_file: + return json.load(scenario_file) + + +def read_path(value, path_parts, label): + current = value + for part in path_parts: + if isinstance(current, list) and isinstance(part, int): + if part >= len(current): + fail(f"{label} path {path_parts!r} index {part} is out of range") + current = current[part] + continue + + if isinstance(current, dict) and isinstance(part, str): + if part not in current: + fail(f"{label} path {path_parts!r} is missing key {part!r}") + current = current[part] + continue + + fail(f"{label} path {path_parts!r} cannot read {part!r} from {current!r}") + + return current + + +def resolve_value(value_spec, context, label): + if "value" in value_spec: + return value_spec["value"] + + source = value_spec.get("source") + if not isinstance(source, dict): + fail(f"{label} value spec has no literal value or source") + + root = source.get("root") + if root not in context: + fail(f"{label} value source root {root!r} is unavailable") + + path_parts = source.get("path") or [] + if not isinstance(path_parts, list): + fail(f"{label} value source path must be a list") + + return read_path(context[root], path_parts, label) + + +def response_data(response, operation): + data = response.data + if not isinstance(data, dict): + fail(f"{operation} returned non-JSON data: {data!r}") + if data.get("error"): + fail(f"{operation} returned {data.get('error')}: {data.get('message')}") + return data + + +def create_assembly(client, scenario): + feature = scenario["createTusAssembly"] + input_values = list(feature["input"].values()) + if len(input_values) != 1: + fail(f"{feature['featureId']} expected exactly one input value") + + response = client.create_tus_assembly(input_values[0]) + data = response_data(response, feature["featureId"]) + for required_path in feature["requiredResponsePaths"]: + value = read_path(data, required_path, feature["featureId"]) + if value is None or value == "": + fail(f"{feature['featureId']} returned empty value at {required_path!r}") + return data + + +def scenario_bytes(scenario): + source = scenario["upload"]["source"] + if source["kind"] != "bytes": + fail(f"unsupported scenario source kind {source['kind']!r}") + if source["encoding"] != "utf8": + fail(f"unsupported scenario source encoding {source['encoding']!r}") + return source["value"].encode("utf-8") + + +def upload_metadata(scenario, create_response): + context = {"createResponse": create_response, "scenario": scenario} + metadata = {} + for field in scenario["upload"]["metadata"]: + metadata[field["name"]] = str(resolve_value(field["value"], context, field["name"])) + return metadata + + +def upload_with_tus(scenario, create_response): + context = {"createResponse": create_response, "scenario": scenario} + endpoint_url = str(resolve_value(scenario["upload"]["tusUrl"], context, "tusUrl")) + content = scenario_bytes(scenario) + chunk_size = len(content) if scenario["upload"]["chunkSize"] == "full-file" else None + if chunk_size is None: + fail(f"unsupported chunk size policy {scenario['upload']['chunkSize']!r}") + + uploader = tus.TusClient(endpoint_url).uploader( + file_stream=BytesIO(content), + chunk_size=chunk_size, + metadata=upload_metadata(scenario, create_response), + retries=scenario["upload"]["retries"], + ) + uploader.upload() + if not uploader.url: + fail("TUS upload did not expose an upload URL") + if uploader.offset != len(content): + fail(f"TUS upload offset {uploader.offset}, expected {len(content)}") + return uploader.url + + +def render_path_template(template_config, context, label): + rendered = template_config["template"] + for name, value_spec in template_config["replacements"].items(): + value = resolve_value(value_spec, context, f"{label}.{name}") + rendered = rendered.replace("{" + name + "}", quote(str(value), safe="")) + + if "{" in rendered or "}" in rendered: + fail(f"{label} still has unresolved placeholders: {rendered}") + + return rendered + + +def wait_for_assembly(client, scenario, create_response): + feature = scenario["waitForAssembly"] + context = {"createResponse": create_response, "scenario": scenario} + wait_input = render_path_template(feature["input"], context, feature["featureId"]) + return response_data(client.wait_for_assembly(wait_input), feature["featureId"]) + + +def run_assertions(scenario, create_response, status, upload_url): + context = { + "captured": {"uploadUrl": upload_url}, + "createResponse": create_response, + "scenario": scenario, + "status": status, + } + + for index, assertion in enumerate(scenario["assertions"]): + label = f"assertions[{index}]" + actual = resolve_value(assertion["actual"], context, f"{label}.actual") + expected = resolve_value(assertion["expected"], context, f"{label}.expected") + + if assertion["kind"] == "equals": + if actual != expected: + fail(f"{label} expected {expected!r}, got {actual!r}") + continue + + if assertion["kind"] == "length": + if len(actual) != expected: + fail(f"{label} expected length {expected!r}, got {len(actual)!r}") + continue + + fail(f"{label} has unsupported assertion kind {assertion['kind']!r}") + + +def main(): + scenario = load_scenario() + endpoint = required_env("TRANSLOADIT_ENDPOINT") + client = Transloadit( + auth_key=required_env("TRANSLOADIT_KEY"), + auth_secret=required_env("TRANSLOADIT_SECRET"), + service=endpoint, + ) + + create_response = create_assembly(client, scenario) + upload_url = upload_with_tus(scenario, create_response) + status = wait_for_assembly(client, scenario, create_response) + run_assertions(scenario, create_response, status, upload_url) + + print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") + + +if __name__ == "__main__": + main() diff --git a/tests/test_examples.py b/tests/test_examples.py index 25a090b..14d4f07 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -36,6 +36,11 @@ def test_examples_import_without_side_effects(): runpy.run_path(str(example_path), run_name="__example_import__") +def test_devdock_examples_import_without_side_effects(): + for example_path in sorted(EXAMPLES_ROOT.glob("api2-devdock-*/main.py")): + runpy.run_path(str(example_path), run_name="__example_import__") + + def test_smart_cdn_example_runs_without_network(): env = { **os.environ, From fcb4535352f25a02725accdd30f533564333426e Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Mon, 1 Jun 2026 23:00:43 +0200 Subject: [PATCH 33/64] Let API2 assert devdock example result --- examples/api2-devdock-tus-assembly/main.py | 42 +++++++++------------- 1 file changed, 17 insertions(+), 25 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index 92ae790..8fe2f9d 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -156,30 +156,22 @@ def wait_for_assembly(client, scenario, create_response): return response_data(client.wait_for_assembly(wait_input), feature["featureId"]) -def run_assertions(scenario, create_response, status, upload_url): - context = { - "captured": {"uploadUrl": upload_url}, - "createResponse": create_response, - "scenario": scenario, - "status": status, - } - - for index, assertion in enumerate(scenario["assertions"]): - label = f"assertions[{index}]" - actual = resolve_value(assertion["actual"], context, f"{label}.actual") - expected = resolve_value(assertion["expected"], context, f"{label}.expected") - - if assertion["kind"] == "equals": - if actual != expected: - fail(f"{label} expected {expected!r}, got {actual!r}") - continue - - if assertion["kind"] == "length": - if len(actual) != expected: - fail(f"{label} expected length {expected!r}, got {len(actual)!r}") - continue - - fail(f"{label} has unsupported assertion kind {assertion['kind']!r}") +def write_result(create_response, status, upload_url): + result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") + if not result_path: + return + + with Path(result_path).open("w", encoding="utf-8") as result_file: + json.dump( + { + "createResponse": create_response, + "status": status, + "uploadUrl": upload_url, + }, + result_file, + indent=2, + ) + result_file.write("\n") def main(): @@ -194,7 +186,7 @@ def main(): create_response = create_assembly(client, scenario) upload_url = upload_with_tus(scenario, create_response) status = wait_for_assembly(client, scenario, create_response) - run_assertions(scenario, create_response, status, upload_url) + write_result(create_response, status, upload_url) print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") From c02c48f701f1dfa5b0b0e01d71cfd95ffa6f3343 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 2 Jun 2026 03:23:11 +0200 Subject: [PATCH 34/64] Add devdock template lifecycle example --- .../api2-devdock-template-lifecycle/main.py | 193 ++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 examples/api2-devdock-template-lifecycle/main.py diff --git a/examples/api2-devdock-template-lifecycle/main.py b/examples/api2-devdock-template-lifecycle/main.py new file mode 100644 index 0000000..b53a218 --- /dev/null +++ b/examples/api2-devdock-template-lifecycle/main.py @@ -0,0 +1,193 @@ +"""Run the API2 contract Template lifecycle scenario against a devdock API2 server. + +This example is intentionally checked into the SDK repository: it should read +the API facts from API2's injected scenario JSON and exercise public SDK +methods as normal user code would. +""" + +import json +import os +import time +from pathlib import Path + +from transloadit.client import Transloadit + + +def required_env(name): + value = os.environ.get(name) + if not value: + raise RuntimeError(f"{name} must be set") + return value + + +def fail(message): + raise RuntimeError(message) + + +def load_scenario(): + configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") + scenario_path = ( + Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") + ) + with scenario_path.open(encoding="utf-8") as scenario_file: + return json.load(scenario_file) + + +def response_data(response, operation): + data = response.data + if not isinstance(data, dict): + fail(f"{operation} returned non-JSON data: {data!r}") + if data.get("error"): + fail(f"{operation} returned {data.get('error')}: {data.get('message')}") + return data + + +def require_template_id(data, operation): + template_id = data.get("id") or data.get("template_id") + if not template_id: + fail(f"{operation} returned no template id: {data!r}") + return template_id + + +def template_content(content): + if not isinstance(content, dict): + fail(f"template content must be an object: {content!r}") + + return dict(content) + + +def template_payload(name, config): + require_signature_auth = 1 if config["requireSignatureAuth"] else 0 + return { + "name": name, + "require_signature_auth": require_signature_auth, + "template": template_content(config["content"]), + } + + +def response_flag(data, *names): + for name in names: + if name in data: + value = data[name] + if isinstance(value, bool): + return value + if isinstance(value, int): + return value != 0 + if isinstance(value, str): + return value.lower() in ("1", "true", "yes") + return False + + +def template_result(data): + content = data.get("content") or data.get("template") or {} + if not isinstance(content, dict): + fail(f"template response content must be an object: {content!r}") + + return { + "content": content, + "id": data.get("id") or data.get("template_id"), + "name": data.get("name") or data.get("template_name"), + "requireSignatureAuth": response_flag( + data, + "require_signature_auth", + "requireSignatureAuth", + ), + } + + +def list_count(data): + count = data.get("count") + if isinstance(count, int): + return count + + items = data.get("items") + if isinstance(items, list): + return len(items) + + fail(f"template list response did not contain a count or items list: {data!r}") + + +def deleted_get_result(response): + data = response.data + if not isinstance(data, dict): + return False, "" + + error_code = data.get("error") + if isinstance(error_code, str) and error_code: + return False, error_code + + return response.status_code is not None and response.status_code < 400, "" + + +def write_result(result): + result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") + if not result_path: + return + + with Path(result_path).open("w", encoding="utf-8") as result_file: + json.dump(result, result_file, indent=2) + result_file.write("\n") + + +def main(): + scenario = load_scenario() + endpoint = required_env("TRANSLOADIT_ENDPOINT") + client = Transloadit( + auth_key=required_env("TRANSLOADIT_KEY"), + auth_secret=required_env("TRANSLOADIT_SECRET"), + service=endpoint, + ) + + template_name = f"{scenario['template']['namePrefix']}-{time.time_ns()}" + template_id = None + delete_template = True + + try: + created = response_data( + client.create_template(template_payload(template_name, scenario["template"])), + "createTemplate", + ) + template_id = require_template_id(created, "createTemplate") + + fetched = response_data(client.get_template(template_id), "getTemplate") + listed = response_data( + client.list_templates({"pagesize": scenario["list"]["pageSize"]}), + "listTemplates", + ) + + updated_template_name = f"{template_name}{scenario['update']['nameSuffix']}" + response_data( + client.update_template( + template_id, + template_payload(updated_template_name, scenario["update"]), + ), + "updateTemplate", + ) + updated = response_data(client.get_template(template_id), "getTemplate updated") + + response_data(client.delete_template(template_id), "deleteTemplate") + delete_template = False + + deleted_get_succeeded, deleted_error_code = deleted_get_result(client.get_template(template_id)) + + write_result( + { + "deletedErrorCode": deleted_error_code, + "deletedGetSucceeded": deleted_get_succeeded, + "fetched": template_result(fetched), + "listCount": list_count(listed), + "templateId": template_id, + "templateName": template_name, + "updated": template_result(updated), + "updatedTemplateName": updated_template_name, + } + ) + finally: + if template_id and delete_template: + client.delete_template(template_id) + + print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") + + +if __name__ == "__main__": + main() From 75f0049fd4c0da5c8f2c0decdc1f66d7f5f586a6 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 2 Jun 2026 03:26:54 +0200 Subject: [PATCH 35/64] Fix devdock template content payload --- examples/api2-devdock-template-lifecycle/main.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/examples/api2-devdock-template-lifecycle/main.py b/examples/api2-devdock-template-lifecycle/main.py index b53a218..f9f9fdc 100644 --- a/examples/api2-devdock-template-lifecycle/main.py +++ b/examples/api2-devdock-template-lifecycle/main.py @@ -53,7 +53,10 @@ def template_content(content): if not isinstance(content, dict): fail(f"template content must be an object: {content!r}") - return dict(content) + rendered = dict(content.get("additionalProperties") or {}) + rendered["steps"] = content["steps"] + + return rendered def template_payload(name, config): From 41484c2e041ba36db6f79af36d58711c49c8d9b8 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 2 Jun 2026 05:37:05 +0200 Subject: [PATCH 36/64] Read TUS scenario steps generically --- examples/api2-devdock-tus-assembly/main.py | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index 8fe2f9d..1ef26c9 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -83,8 +83,25 @@ def response_data(response, operation): return data +def feature_step(scenario, collection_name, feature_id, kind): + steps = scenario.get(collection_name) + if not isinstance(steps, list): + fail(f"{collection_name} must be a list") + + for index, step in enumerate(steps): + if not isinstance(step, dict): + fail(f"{collection_name}[{index}] must be an object") + if step.get("featureId") != feature_id: + continue + if step.get("kind") != kind: + fail(f"{collection_name}[{index}] must have kind {kind!r}") + return step + + fail(f"scenario has no {collection_name} step for feature {feature_id!r}") + + def create_assembly(client, scenario): - feature = scenario["createTusAssembly"] + feature = feature_step(scenario, "preparations", "createTusAssembly", "feature-call") input_values = list(feature["input"].values()) if len(input_values) != 1: fail(f"{feature['featureId']} expected exactly one input value") @@ -150,7 +167,7 @@ def render_path_template(template_config, context, label): def wait_for_assembly(client, scenario, create_response): - feature = scenario["waitForAssembly"] + feature = feature_step(scenario, "observations", "waitForAssembly", "feature-poll") context = {"createResponse": create_response, "scenario": scenario} wait_input = render_path_template(feature["input"], context, feature["featureId"]) return response_data(client.wait_for_assembly(wait_input), feature["featureId"]) From 67407bf451eb8965e12329f99f45bedd357a3704 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Tue, 2 Jun 2026 07:45:26 +0200 Subject: [PATCH 37/64] Generate TUS assembly upload helper --- examples/api2-devdock-tus-assembly/main.py | 121 ++++----------------- transloadit/async_client.py | 68 ++++++++++++ transloadit/client.py | 68 ++++++++++++ 3 files changed, 156 insertions(+), 101 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index 1ef26c9..c265fd3 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -7,12 +7,9 @@ import json import os -from io import BytesIO from pathlib import Path -from urllib.parse import quote from transloadit.client import Transloadit -from tusclient import client as tus def required_env(name): @@ -35,45 +32,6 @@ def load_scenario(): return json.load(scenario_file) -def read_path(value, path_parts, label): - current = value - for part in path_parts: - if isinstance(current, list) and isinstance(part, int): - if part >= len(current): - fail(f"{label} path {path_parts!r} index {part} is out of range") - current = current[part] - continue - - if isinstance(current, dict) and isinstance(part, str): - if part not in current: - fail(f"{label} path {path_parts!r} is missing key {part!r}") - current = current[part] - continue - - fail(f"{label} path {path_parts!r} cannot read {part!r} from {current!r}") - - return current - - -def resolve_value(value_spec, context, label): - if "value" in value_spec: - return value_spec["value"] - - source = value_spec.get("source") - if not isinstance(source, dict): - fail(f"{label} value spec has no literal value or source") - - root = source.get("root") - if root not in context: - fail(f"{label} value source root {root!r} is unavailable") - - path_parts = source.get("path") or [] - if not isinstance(path_parts, list): - fail(f"{label} value source path must be a list") - - return read_path(context[root], path_parts, label) - - def response_data(response, operation): data = response.data if not isinstance(data, dict): @@ -100,19 +58,13 @@ def feature_step(scenario, collection_name, feature_id, kind): fail(f"scenario has no {collection_name} step for feature {feature_id!r}") -def create_assembly(client, scenario): +def file_count(scenario): feature = feature_step(scenario, "preparations", "createTusAssembly", "feature-call") input_values = list(feature["input"].values()) if len(input_values) != 1: fail(f"{feature['featureId']} expected exactly one input value") - response = client.create_tus_assembly(input_values[0]) - data = response_data(response, feature["featureId"]) - for required_path in feature["requiredResponsePaths"]: - value = read_path(data, required_path, feature["featureId"]) - if value is None or value == "": - fail(f"{feature['featureId']} returned empty value at {required_path!r}") - return data + return input_values[0] def scenario_bytes(scenario): @@ -124,53 +76,14 @@ def scenario_bytes(scenario): return source["value"].encode("utf-8") -def upload_metadata(scenario, create_response): - context = {"createResponse": create_response, "scenario": scenario} - metadata = {} - for field in scenario["upload"]["metadata"]: - metadata[field["name"]] = str(resolve_value(field["value"], context, field["name"])) - return metadata - - -def upload_with_tus(scenario, create_response): - context = {"createResponse": create_response, "scenario": scenario} - endpoint_url = str(resolve_value(scenario["upload"]["tusUrl"], context, "tusUrl")) - content = scenario_bytes(scenario) - chunk_size = len(content) if scenario["upload"]["chunkSize"] == "full-file" else None - if chunk_size is None: - fail(f"unsupported chunk size policy {scenario['upload']['chunkSize']!r}") - - uploader = tus.TusClient(endpoint_url).uploader( - file_stream=BytesIO(content), - chunk_size=chunk_size, - metadata=upload_metadata(scenario, create_response), - retries=scenario["upload"]["retries"], - ) - uploader.upload() - if not uploader.url: - fail("TUS upload did not expose an upload URL") - if uploader.offset != len(content): - fail(f"TUS upload offset {uploader.offset}, expected {len(content)}") - return uploader.url - - -def render_path_template(template_config, context, label): - rendered = template_config["template"] - for name, value_spec in template_config["replacements"].items(): - value = resolve_value(value_spec, context, f"{label}.{name}") - rendered = rendered.replace("{" + name + "}", quote(str(value), safe="")) - - if "{" in rendered or "}" in rendered: - fail(f"{label} still has unresolved placeholders: {rendered}") - - return rendered - - -def wait_for_assembly(client, scenario, create_response): - feature = feature_step(scenario, "observations", "waitForAssembly", "feature-poll") - context = {"createResponse": create_response, "scenario": scenario} - wait_input = render_path_template(feature["input"], context, feature["featureId"]) - return response_data(client.wait_for_assembly(wait_input), feature["featureId"]) +def upload_config(scenario): + upload = scenario["upload"] + return { + "content": scenario_bytes(scenario), + "fieldname": upload["fieldName"], + "filename": upload["fileName"], + "user_meta": upload.get("userMeta") or {}, + } def write_result(create_response, status, upload_url): @@ -200,10 +113,16 @@ def main(): service=endpoint, ) - create_response = create_assembly(client, scenario) - upload_url = upload_with_tus(scenario, create_response) - status = wait_for_assembly(client, scenario, create_response) - write_result(create_response, status, upload_url) + upload = upload_config(scenario) + completed_assembly, upload_url = client.upload_tus_assembly( + file_count(scenario), + upload["content"], + upload["fieldname"], + upload["filename"], + upload["user_meta"], + ) + status = response_data(completed_assembly, "uploadTusAssembly") + write_result(status, status, upload_url) print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 7e0e302..7b2ddf2 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -267,6 +267,74 @@ async def create_tus_assembly(self, file_count: int): return assembly + async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): + """ + Create a TUS-ready Assembly, upload one file with the TUS protocol, and wait for the Assembly to finish. + """ + createdAssembly = await self.create_tus_assembly(file_count) + + import base64 + from urllib.parse import urljoin + + endpointUrl = createdAssembly.data.get("tus_url") + if not endpointUrl: + raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") + + metadataMap = {} + if user_meta: + metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) + metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_url")) + metadataMap["fieldname"] = str(fieldname) + metadataMap["filename"] = str(filename) + + session = await self.request._ensure_session() + + createHeaders = {} + createHeaders["Tus-Resumable"] = "1.0.0" + createHeaders["Upload-Length"] = str(len(content)) + createMetadataParts = [] + for key, value in metadataMap.items(): + encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") + createMetadataParts.append(f"{key} {encoded_value}") + createHeaders["Upload-Metadata"] = ",".join(createMetadataParts) + async with session.request( + "POST", + endpointUrl, + data=b"", + headers=createHeaders, + timeout=self.request._timeout(), + ) as createResponse: + if createResponse.status != 201: + raise RuntimeError(f"TUS create returned HTTP {createResponse.status}, expected 201") + uploadUrlLocation = createResponse.headers.get("Location") + if not uploadUrlLocation: + raise RuntimeError("TUS create did not return a Location header") + uploadUrlText = urljoin(endpointUrl, uploadUrlLocation) + + uploadHeaders = {} + uploadHeaders["Tus-Resumable"] = "1.0.0" + uploadHeaders["Upload-Offset"] = "0" + uploadHeaders["Content-Type"] = "application/offset+octet-stream" + async with session.request( + "PATCH", + uploadUrlText, + data=content, + headers=uploadHeaders, + timeout=self.request._timeout(), + ) as uploadResponse: + if uploadResponse.status != 204: + raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status}, expected 204") + try: + remote_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + except ValueError as error: + raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error + if remote_offset != len(content): + raise RuntimeError(f"TUS upload offset {remote_offset}, expected {len(content)}") + + completedAssembly = await self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) + + return completedAssembly, uploadUrlText + async def wait_for_assembly(self, assembly_url: str): """ Wait for an Assembly to finish uploading and executing. diff --git a/transloadit/client.py b/transloadit/client.py index d0b0167..086166f 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -275,6 +275,74 @@ def create_tus_assembly(self, file_count: int): return assembly + def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): + """ + Create a TUS-ready Assembly, upload one file with the TUS protocol, and wait for the Assembly to finish. + """ + createdAssembly = self.create_tus_assembly(file_count) + + import base64 + from urllib.parse import urljoin + + import requests + + endpointUrl = createdAssembly.data.get("tus_url") + if not endpointUrl: + raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") + + metadataMap = {} + if user_meta: + metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) + metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_url")) + metadataMap["fieldname"] = str(fieldname) + metadataMap["filename"] = str(filename) + + createHeaders = {} + createHeaders["Tus-Resumable"] = "1.0.0" + createHeaders["Upload-Length"] = str(len(content)) + createMetadataParts = [] + for key, value in metadataMap.items(): + encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") + createMetadataParts.append(f"{key} {encoded_value}") + createHeaders["Upload-Metadata"] = ",".join(createMetadataParts) + createResponse = requests.request( + "POST", + endpointUrl, + data=b"", + headers=createHeaders, + timeout=request.TIMEOUT, + ) + if createResponse.status_code != 201: + raise RuntimeError(f"TUS create returned HTTP {createResponse.status_code}, expected 201") + uploadUrlLocation = createResponse.headers.get("Location") + if not uploadUrlLocation: + raise RuntimeError("TUS create did not return a Location header") + uploadUrlText = urljoin(endpointUrl, uploadUrlLocation) + + uploadHeaders = {} + uploadHeaders["Tus-Resumable"] = "1.0.0" + uploadHeaders["Upload-Offset"] = "0" + uploadHeaders["Content-Type"] = "application/offset+octet-stream" + uploadResponse = requests.request( + "PATCH", + uploadUrlText, + data=content, + headers=uploadHeaders, + timeout=request.TIMEOUT, + ) + if uploadResponse.status_code != 204: + raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status_code}, expected 204") + try: + remote_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + except ValueError as error: + raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error + if remote_offset != len(content): + raise RuntimeError(f"TUS upload offset {remote_offset}, expected {len(content)}") + + completedAssembly = self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) + + return completedAssembly, uploadUrlText + def wait_for_assembly(self, assembly_url: str): """ Wait for an Assembly to finish uploading and executing. From 9737ecc8c02b7f4e8a15c511d1f3b9090404dd38 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 3 Jun 2026 01:01:35 +0200 Subject: [PATCH 38/64] Use header-derived TUS offset variable --- transloadit/async_client.py | 6 +++--- transloadit/client.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 7b2ddf2..26844ba 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -325,11 +325,11 @@ async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: if uploadResponse.status != 204: raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status}, expected 204") try: - remote_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + upload_offset = int(uploadResponse.headers.get("Upload-Offset", "")) except ValueError as error: raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if remote_offset != len(content): - raise RuntimeError(f"TUS upload offset {remote_offset}, expected {len(content)}") + if upload_offset != len(content): + raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") completedAssembly = await self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) diff --git a/transloadit/client.py b/transloadit/client.py index 086166f..b1d1209 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -333,11 +333,11 @@ def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, f if uploadResponse.status_code != 204: raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status_code}, expected 204") try: - remote_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + upload_offset = int(uploadResponse.headers.get("Upload-Offset", "")) except ValueError as error: raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if remote_offset != len(content): - raise RuntimeError(f"TUS upload offset {remote_offset}, expected {len(content)}") + if upload_offset != len(content): + raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") completedAssembly = self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) From 315774a08d14f421e6c76bec790f8c8e2c505c3a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 3 Jun 2026 05:05:48 +0200 Subject: [PATCH 39/64] Read TUS example input from SDK feature call --- examples/api2-devdock-tus-assembly/main.py | 71 +++++++++++----------- 1 file changed, 37 insertions(+), 34 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index c265fd3..4171b7f 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -41,48 +41,50 @@ def response_data(response, operation): return data -def feature_step(scenario, collection_name, feature_id, kind): - steps = scenario.get(collection_name) - if not isinstance(steps, list): - fail(f"{collection_name} must be a list") - - for index, step in enumerate(steps): - if not isinstance(step, dict): - fail(f"{collection_name}[{index}] must be an object") - if step.get("featureId") != feature_id: +def sdk_feature_call(scenario, feature_id): + feature_calls = scenario.get("sdkFeatureCalls") + if not isinstance(feature_calls, list): + fail("sdkFeatureCalls must be a list") + + for index, feature_call in enumerate(feature_calls): + if not isinstance(feature_call, dict): + fail(f"sdkFeatureCalls[{index}] must be an object") + if feature_call.get("featureId") != feature_id: continue - if step.get("kind") != kind: - fail(f"{collection_name}[{index}] must have kind {kind!r}") - return step + if feature_call.get("kind") != "sdk-feature-call": + fail(f"sdkFeatureCalls[{index}] must have kind 'sdk-feature-call'") + return feature_call - fail(f"scenario has no {collection_name} step for feature {feature_id!r}") + fail(f"scenario has no SDK feature call for feature {feature_id!r}") -def file_count(scenario): - feature = feature_step(scenario, "preparations", "createTusAssembly", "feature-call") - input_values = list(feature["input"].values()) - if len(input_values) != 1: - fail(f"{feature['featureId']} expected exactly one input value") +def upload_tus_assembly_input(scenario): + feature_call = sdk_feature_call(scenario, "uploadTusAssembly") + input_values = feature_call.get("input") + if not isinstance(input_values, dict): + fail("sdkFeatureCalls.uploadTusAssembly.input must be an object") - return input_values[0] + return input_values -def scenario_bytes(scenario): - source = scenario["upload"]["source"] - if source["kind"] != "bytes": - fail(f"unsupported scenario source kind {source['kind']!r}") - if source["encoding"] != "utf8": - fail(f"unsupported scenario source encoding {source['encoding']!r}") - return source["value"].encode("utf-8") +def scenario_bytes(upload): + content = upload.get("content") + if not isinstance(content, str): + fail("sdkFeatureCalls.uploadTusAssembly.input.upload.content must be a string") + return content.encode("utf-8") + + +def upload_config(input_values): + upload = input_values.get("upload") + if not isinstance(upload, dict): + fail("sdkFeatureCalls.uploadTusAssembly.input.upload must be an object") -def upload_config(scenario): - upload = scenario["upload"] return { - "content": scenario_bytes(scenario), - "fieldname": upload["fieldName"], - "filename": upload["fileName"], - "user_meta": upload.get("userMeta") or {}, + "content": scenario_bytes(upload), + "fieldname": upload["fieldname"], + "filename": upload["filename"], + "user_meta": upload.get("user_meta") or {}, } @@ -113,9 +115,10 @@ def main(): service=endpoint, ) - upload = upload_config(scenario) + input_values = upload_tus_assembly_input(scenario) + upload = upload_config(input_values) completed_assembly, upload_url = client.upload_tus_assembly( - file_count(scenario), + input_values["file_count"], upload["content"], upload["fieldname"], upload["filename"], From 940694015243d82224cc738e731e5559e4a83b33 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 3 Jun 2026 21:07:51 +0200 Subject: [PATCH 40/64] Read SDK example input projection --- examples/api2-devdock-tus-assembly/main.py | 48 +++++++++++----------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index 4171b7f..7e68dc0 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -41,28 +41,22 @@ def response_data(response, operation): return data -def sdk_feature_call(scenario, feature_id): - feature_calls = scenario.get("sdkFeatureCalls") - if not isinstance(feature_calls, list): - fail("sdkFeatureCalls must be a list") - - for index, feature_call in enumerate(feature_calls): - if not isinstance(feature_call, dict): - fail(f"sdkFeatureCalls[{index}] must be an object") - if feature_call.get("featureId") != feature_id: - continue - if feature_call.get("kind") != "sdk-feature-call": - fail(f"sdkFeatureCalls[{index}] must have kind 'sdk-feature-call'") - return feature_call - - fail(f"scenario has no SDK feature call for feature {feature_id!r}") - - -def upload_tus_assembly_input(scenario): - feature_call = sdk_feature_call(scenario, "uploadTusAssembly") - input_values = feature_call.get("input") +def example_input(scenario): + input_values = scenario.get("exampleInput") if not isinstance(input_values, dict): - fail("sdkFeatureCalls.uploadTusAssembly.input must be an object") + fail("exampleInput must be an object") + + return input_values + + +def upload_tus_assembly_input(example_input_values): + feature_inputs = example_input_values.get("sdkFeatureInputs") + if not isinstance(feature_inputs, dict): + fail("exampleInput.sdkFeatureInputs must be an object") + + input_values = feature_inputs.get("uploadTusAssembly") + if not isinstance(input_values, dict): + fail("exampleInput.sdkFeatureInputs.uploadTusAssembly must be an object") return input_values @@ -70,7 +64,7 @@ def upload_tus_assembly_input(scenario): def scenario_bytes(upload): content = upload.get("content") if not isinstance(content, str): - fail("sdkFeatureCalls.uploadTusAssembly.input.upload.content must be a string") + fail("exampleInput.sdkFeatureInputs.uploadTusAssembly.upload.content must be a string") return content.encode("utf-8") @@ -78,7 +72,7 @@ def scenario_bytes(upload): def upload_config(input_values): upload = input_values.get("upload") if not isinstance(upload, dict): - fail("sdkFeatureCalls.uploadTusAssembly.input.upload must be an object") + fail("exampleInput.sdkFeatureInputs.uploadTusAssembly.upload must be an object") return { "content": scenario_bytes(upload), @@ -115,7 +109,8 @@ def main(): service=endpoint, ) - input_values = upload_tus_assembly_input(scenario) + example_input_values = example_input(scenario) + input_values = upload_tus_assembly_input(example_input_values) upload = upload_config(input_values) completed_assembly, upload_url = client.upload_tus_assembly( input_values["file_count"], @@ -127,7 +122,10 @@ def main(): status = response_data(completed_assembly, "uploadTusAssembly") write_result(status, status, upload_url) - print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") + print( + "Python Transloadit SDK devdock scenario " + f"{example_input_values['scenarioId']} passed for {endpoint}" + ) if __name__ == "__main__": From 51c5439b5203ebb208f83c22756c482131053468 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Fri, 5 Jun 2026 18:29:58 +0200 Subject: [PATCH 41/64] Regenerate required feature value guards --- transloadit/async_client.py | 13 ++++++++----- transloadit/client.py | 13 ++++++++----- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 26844ba..21bd3ea 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -247,7 +247,7 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict async def create_tus_assembly(self, file_count: int): """ - Create a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. + Creates a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. """ assembly = await self.create_assembly( data={ @@ -269,7 +269,7 @@ async def create_tus_assembly(self, file_count: int): async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ - Create a TUS-ready Assembly, upload one file with the TUS protocol, and wait for the Assembly to finish. + Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ createdAssembly = await self.create_tus_assembly(file_count) @@ -331,14 +331,17 @@ async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: if upload_offset != len(content): raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - completedAssembly = await self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) + createdAssemblyAssemblySslUrl = createdAssembly.data.get("assembly_ssl_url") + if not createdAssemblyAssemblySslUrl: + raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") + completedAssembly = await self.wait_for_assembly(createdAssemblyAssemblySslUrl) return completedAssembly, uploadUrlText async def wait_for_assembly(self, assembly_url: str): """ - Wait for an Assembly to finish uploading and executing. - The assembly URL should be the assembly_ssl_url returned by create_assembly. + Waits for an Assembly to finish uploading and executing. + Use the returned assembly_ssl_url as the assembly URL. """ while True: response = await self.get_assembly(assembly_url=assembly_url) diff --git a/transloadit/client.py b/transloadit/client.py index b1d1209..3d28b0d 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -255,7 +255,7 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No def create_tus_assembly(self, file_count: int): """ - Create a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. + Creates a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. """ assembly = self.create_assembly( data={ @@ -277,7 +277,7 @@ def create_tus_assembly(self, file_count: int): def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ - Create a TUS-ready Assembly, upload one file with the TUS protocol, and wait for the Assembly to finish. + Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ createdAssembly = self.create_tus_assembly(file_count) @@ -339,14 +339,17 @@ def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, f if upload_offset != len(content): raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - completedAssembly = self.wait_for_assembly(createdAssembly.data.get("assembly_ssl_url")) + createdAssemblyAssemblySslUrl = createdAssembly.data.get("assembly_ssl_url") + if not createdAssemblyAssemblySslUrl: + raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") + completedAssembly = self.wait_for_assembly(createdAssemblyAssemblySslUrl) return completedAssembly, uploadUrlText def wait_for_assembly(self, assembly_url: str): """ - Wait for an Assembly to finish uploading and executing. - The assembly URL should be the assembly_ssl_url returned by create_assembly. + Waits for an Assembly to finish uploading and executing. + Use the returned assembly_ssl_url as the assembly URL. """ while True: response = self.get_assembly(assembly_url=assembly_url) From 19186b1a90e82fbc8f24743a5c03668962f44272 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 10 Jun 2026 06:14:27 +0200 Subject: [PATCH 42/64] Add Assembly lifecycle devdock example --- .../api2-devdock-assembly-lifecycle/main.py | 157 ++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 examples/api2-devdock-assembly-lifecycle/main.py diff --git a/examples/api2-devdock-assembly-lifecycle/main.py b/examples/api2-devdock-assembly-lifecycle/main.py new file mode 100644 index 0000000..219441a --- /dev/null +++ b/examples/api2-devdock-assembly-lifecycle/main.py @@ -0,0 +1,157 @@ +"""Run the API2 contract Assembly lifecycle scenario against a devdock API2 server. + +This example is intentionally checked into the SDK repository: it should read +the API facts from API2's injected scenario JSON and exercise public SDK +methods as normal user code would. +""" + +import json +import os +from pathlib import Path + +from transloadit.client import Transloadit + + +def required_env(name): + value = os.environ.get(name) + if not value: + raise RuntimeError(f"{name} must be set") + return value + + +def fail(message): + raise RuntimeError(message) + + +def load_scenario(): + configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") + scenario_path = ( + Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") + ) + with scenario_path.open(encoding="utf-8") as scenario_file: + return json.load(scenario_file) + + +def response_data(response, operation): + data = response.data + if not isinstance(data, dict): + fail(f"{operation} returned non-JSON data: {data!r}") + if data.get("error"): + fail(f"{operation} returned {data.get('error')}: {data.get('message')}") + return data + + +def assembly_result(data): + return { + "assemblyId": data.get("assembly_id") or data.get("assemblyId") or data.get("id"), + "assemblySslUrl": data.get("assembly_ssl_url") or data.get("assemblySslUrl"), + "assemblyUrl": data.get("assembly_url") or data.get("assemblyUrl"), + "ok": data.get("ok"), + } + + +def list_items(data): + items = data.get("items") + if isinstance(items, list): + return items + + assemblies = data.get("assemblies") + if isinstance(assemblies, list): + return assemblies + + fail(f"assembly list response did not contain items or assemblies: {data!r}") + + +def list_count(data): + count = data.get("count") + if isinstance(count, int): + return count + + return len(list_items(data)) + + +def item_assembly_id(item): + if not isinstance(item, dict): + return None + + return item.get("assembly_id") or item.get("assemblyId") or item.get("id") + + +def write_result(result): + result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") + if not result_path: + return + + with Path(result_path).open("w", encoding="utf-8") as result_file: + json.dump(result, result_file, indent=2) + result_file.write("\n") + + +def main(): + scenario = load_scenario() + endpoint = required_env("TRANSLOADIT_ENDPOINT") + client = Transloadit( + auth_key=required_env("TRANSLOADIT_KEY"), + auth_secret=required_env("TRANSLOADIT_SECRET"), + service=endpoint, + ) + + created = response_data( + client.create_tus_assembly(scenario["assembly"]["fileCount"]), + "createTusAssembly", + ) + created_result = assembly_result(created) + assembly_id = created_result["assemblyId"] + assembly_url = created_result["assemblySslUrl"] + if not assembly_id: + fail(f"createTusAssembly returned no assembly id: {created!r}") + if not assembly_url: + fail(f"createTusAssembly returned no assembly_ssl_url: {created!r}") + + cancel_on_exit = True + + try: + fetched = response_data( + client.get_assembly(assembly_url=assembly_url), + "getAssemblyStatus", + ) + listed = response_data( + client.list_assemblies( + { + "assembly_id": assembly_id, + "pagesize": scenario["list"]["pageSize"], + } + ), + "listAssemblies", + ) + + listed_items = list_items(listed) + cancelled = response_data( + client.cancel_assembly(assembly_url=assembly_url), + "cancelAssembly", + ) + cancel_on_exit = False + + write_result( + { + "cancelled": assembly_result(cancelled), + "created": created_result, + "fetched": assembly_result(fetched), + "listContainsCreated": any( + item_assembly_id(item) == assembly_id for item in listed_items + ), + "listCount": list_count(listed), + } + ) + finally: + if cancel_on_exit: + client.cancel_assembly(assembly_url=assembly_url) + + print( + "Python Transloadit SDK devdock scenario " + f"{scenario['scenarioId']} canceled Assembly {assembly_id}" + ) + + +if __name__ == "__main__": + main() From bcf056e7ea400aeae5834404463fcda9cf37f2bd Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 10 Jun 2026 08:48:02 +0200 Subject: [PATCH 43/64] Use SSL Assembly URL for TUS metadata Co-Authored-By: Claude Fable 5 --- transloadit/async_client.py | 2 +- transloadit/client.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 21bd3ea..2cdbe73 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -283,7 +283,7 @@ async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: metadataMap = {} if user_meta: metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) - metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_url")) + metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_ssl_url")) metadataMap["fieldname"] = str(fieldname) metadataMap["filename"] = str(filename) diff --git a/transloadit/client.py b/transloadit/client.py index 3d28b0d..c0a85cb 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -293,7 +293,7 @@ def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, f metadataMap = {} if user_meta: metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) - metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_url")) + metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_ssl_url")) metadataMap["fieldname"] = str(fieldname) metadataMap["filename"] = str(filename) From 6e22acdf6f7584af5ee7a9f386c07b322d24ab6c Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 10 Jun 2026 10:52:09 +0200 Subject: [PATCH 44/64] Regenerate with snake_case locals The API2 Python generator now converts contract identifiers to snake_case for local variable names, so generated methods read like idiomatic Python. No public API or behavior change. Co-Authored-By: Claude Fable 5 --- transloadit/async_client.py | 74 ++++++++++++++++++------------------ transloadit/client.py | 76 ++++++++++++++++++------------------- 2 files changed, 75 insertions(+), 75 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 2cdbe73..90a964a 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -271,72 +271,72 @@ async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ - createdAssembly = await self.create_tus_assembly(file_count) + created_assembly = await self.create_tus_assembly(file_count) import base64 from urllib.parse import urljoin - endpointUrl = createdAssembly.data.get("tus_url") - if not endpointUrl: + endpoint_url = created_assembly.data.get("tus_url") + if not endpoint_url: raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") - metadataMap = {} + metadata_map = {} if user_meta: - metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) - metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_ssl_url")) - metadataMap["fieldname"] = str(fieldname) - metadataMap["filename"] = str(filename) + metadata_map.update({str(key): str(value) for key, value in user_meta.items()}) + metadata_map["assembly_url"] = str(created_assembly.data.get("assembly_ssl_url")) + metadata_map["fieldname"] = str(fieldname) + metadata_map["filename"] = str(filename) session = await self.request._ensure_session() - createHeaders = {} - createHeaders["Tus-Resumable"] = "1.0.0" - createHeaders["Upload-Length"] = str(len(content)) - createMetadataParts = [] - for key, value in metadataMap.items(): + create_headers = {} + create_headers["Tus-Resumable"] = "1.0.0" + create_headers["Upload-Length"] = str(len(content)) + create_metadata_parts = [] + for key, value in metadata_map.items(): encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") - createMetadataParts.append(f"{key} {encoded_value}") - createHeaders["Upload-Metadata"] = ",".join(createMetadataParts) + create_metadata_parts.append(f"{key} {encoded_value}") + create_headers["Upload-Metadata"] = ",".join(create_metadata_parts) async with session.request( "POST", - endpointUrl, + endpoint_url, data=b"", - headers=createHeaders, + headers=create_headers, timeout=self.request._timeout(), - ) as createResponse: - if createResponse.status != 201: - raise RuntimeError(f"TUS create returned HTTP {createResponse.status}, expected 201") - uploadUrlLocation = createResponse.headers.get("Location") - if not uploadUrlLocation: + ) as create_response: + if create_response.status != 201: + raise RuntimeError(f"TUS create returned HTTP {create_response.status}, expected 201") + upload_url_location = create_response.headers.get("Location") + if not upload_url_location: raise RuntimeError("TUS create did not return a Location header") - uploadUrlText = urljoin(endpointUrl, uploadUrlLocation) + upload_url_text = urljoin(endpoint_url, upload_url_location) - uploadHeaders = {} - uploadHeaders["Tus-Resumable"] = "1.0.0" - uploadHeaders["Upload-Offset"] = "0" - uploadHeaders["Content-Type"] = "application/offset+octet-stream" + upload_headers = {} + upload_headers["Tus-Resumable"] = "1.0.0" + upload_headers["Upload-Offset"] = "0" + upload_headers["Content-Type"] = "application/offset+octet-stream" async with session.request( "PATCH", - uploadUrlText, + upload_url_text, data=content, - headers=uploadHeaders, + headers=upload_headers, timeout=self.request._timeout(), - ) as uploadResponse: - if uploadResponse.status != 204: - raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status}, expected 204") + ) as upload_response: + if upload_response.status != 204: + raise RuntimeError(f"TUS upload returned HTTP {upload_response.status}, expected 204") try: - upload_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + upload_offset = int(upload_response.headers.get("Upload-Offset", "")) except ValueError as error: raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error if upload_offset != len(content): raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - createdAssemblyAssemblySslUrl = createdAssembly.data.get("assembly_ssl_url") - if not createdAssemblyAssemblySslUrl: + created_assembly_assembly_ssl_url = created_assembly.data.get("assembly_ssl_url") + if not created_assembly_assembly_ssl_url: raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") - completedAssembly = await self.wait_for_assembly(createdAssemblyAssemblySslUrl) + completed_assembly = await self.wait_for_assembly(created_assembly_assembly_ssl_url) - return completedAssembly, uploadUrlText + return completed_assembly, upload_url_text async def wait_for_assembly(self, assembly_url: str): """ diff --git a/transloadit/client.py b/transloadit/client.py index c0a85cb..00d9e16 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -279,72 +279,72 @@ def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, f """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ - createdAssembly = self.create_tus_assembly(file_count) + created_assembly = self.create_tus_assembly(file_count) import base64 from urllib.parse import urljoin import requests - endpointUrl = createdAssembly.data.get("tus_url") - if not endpointUrl: + endpoint_url = created_assembly.data.get("tus_url") + if not endpoint_url: raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") - metadataMap = {} + metadata_map = {} if user_meta: - metadataMap.update({str(key): str(value) for key, value in user_meta.items()}) - metadataMap["assembly_url"] = str(createdAssembly.data.get("assembly_ssl_url")) - metadataMap["fieldname"] = str(fieldname) - metadataMap["filename"] = str(filename) - - createHeaders = {} - createHeaders["Tus-Resumable"] = "1.0.0" - createHeaders["Upload-Length"] = str(len(content)) - createMetadataParts = [] - for key, value in metadataMap.items(): + metadata_map.update({str(key): str(value) for key, value in user_meta.items()}) + metadata_map["assembly_url"] = str(created_assembly.data.get("assembly_ssl_url")) + metadata_map["fieldname"] = str(fieldname) + metadata_map["filename"] = str(filename) + + create_headers = {} + create_headers["Tus-Resumable"] = "1.0.0" + create_headers["Upload-Length"] = str(len(content)) + create_metadata_parts = [] + for key, value in metadata_map.items(): encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") - createMetadataParts.append(f"{key} {encoded_value}") - createHeaders["Upload-Metadata"] = ",".join(createMetadataParts) - createResponse = requests.request( + create_metadata_parts.append(f"{key} {encoded_value}") + create_headers["Upload-Metadata"] = ",".join(create_metadata_parts) + create_response = requests.request( "POST", - endpointUrl, + endpoint_url, data=b"", - headers=createHeaders, + headers=create_headers, timeout=request.TIMEOUT, ) - if createResponse.status_code != 201: - raise RuntimeError(f"TUS create returned HTTP {createResponse.status_code}, expected 201") - uploadUrlLocation = createResponse.headers.get("Location") - if not uploadUrlLocation: + if create_response.status_code != 201: + raise RuntimeError(f"TUS create returned HTTP {create_response.status_code}, expected 201") + upload_url_location = create_response.headers.get("Location") + if not upload_url_location: raise RuntimeError("TUS create did not return a Location header") - uploadUrlText = urljoin(endpointUrl, uploadUrlLocation) + upload_url_text = urljoin(endpoint_url, upload_url_location) - uploadHeaders = {} - uploadHeaders["Tus-Resumable"] = "1.0.0" - uploadHeaders["Upload-Offset"] = "0" - uploadHeaders["Content-Type"] = "application/offset+octet-stream" - uploadResponse = requests.request( + upload_headers = {} + upload_headers["Tus-Resumable"] = "1.0.0" + upload_headers["Upload-Offset"] = "0" + upload_headers["Content-Type"] = "application/offset+octet-stream" + upload_response = requests.request( "PATCH", - uploadUrlText, + upload_url_text, data=content, - headers=uploadHeaders, + headers=upload_headers, timeout=request.TIMEOUT, ) - if uploadResponse.status_code != 204: - raise RuntimeError(f"TUS upload returned HTTP {uploadResponse.status_code}, expected 204") + if upload_response.status_code != 204: + raise RuntimeError(f"TUS upload returned HTTP {upload_response.status_code}, expected 204") try: - upload_offset = int(uploadResponse.headers.get("Upload-Offset", "")) + upload_offset = int(upload_response.headers.get("Upload-Offset", "")) except ValueError as error: raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error if upload_offset != len(content): raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - createdAssemblyAssemblySslUrl = createdAssembly.data.get("assembly_ssl_url") - if not createdAssemblyAssemblySslUrl: + created_assembly_assembly_ssl_url = created_assembly.data.get("assembly_ssl_url") + if not created_assembly_assembly_ssl_url: raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") - completedAssembly = self.wait_for_assembly(createdAssemblyAssemblySslUrl) + completed_assembly = self.wait_for_assembly(created_assembly_assembly_ssl_url) - return completedAssembly, uploadUrlText + return completed_assembly, upload_url_text def wait_for_assembly(self, assembly_url: str): """ From be626e054c48b9dbd68e8a405317fdd936ed05ac Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Wed, 10 Jun 2026 13:22:58 +0200 Subject: [PATCH 45/64] Move generated TUS imports to module headers The generator no longer emits function-local imports; base64, urljoin, and requests (sync only) now live in the handwritten module headers where Python convention expects them. Co-Authored-By: Claude Fable 5 --- transloadit/async_client.py | 6 ++---- transloadit/client.py | 10 ++++------ 2 files changed, 6 insertions(+), 10 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 90a964a..ebf545d 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -1,6 +1,7 @@ import asyncio +import base64 from typing import Optional -from urllib.parse import quote +from urllib.parse import quote, urljoin from . import async_assembly, async_request, async_template from .api_url import normalize_service_url, require_path_id @@ -273,9 +274,6 @@ async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: """ created_assembly = await self.create_tus_assembly(file_count) - import base64 - from urllib.parse import urljoin - endpoint_url = created_assembly.data.get("tus_url") if not endpoint_url: raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") diff --git a/transloadit/client.py b/transloadit/client.py index 00d9e16..1dc9e4d 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -1,7 +1,10 @@ +import base64 import typing from time import sleep from typing import Optional -from urllib.parse import quote +from urllib.parse import quote, urljoin + +import requests from . import assembly, request, template from .api_url import normalize_service_url, require_path_id @@ -281,11 +284,6 @@ def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, f """ created_assembly = self.create_tus_assembly(file_count) - import base64 - from urllib.parse import urljoin - - import requests - endpoint_url = created_assembly.data.get("tus_url") if not endpoint_url: raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") From 552fed8a856431a4c148215d5224214995bd614d Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Thu, 11 Jun 2026 09:35:00 +0200 Subject: [PATCH 46/64] Prove TUS resume upload via generated SDK method resume_tus_upload() is generated from the API2 resumeUpload TUS protocol contract in both the sync and asyncio clients: it discovers the server offset with a HEAD request, PATCHes the remaining bytes from that offset, asserts the final offset matches the content length, and waits for the Assembly to finish. The new api2-devdock-tus-resume-upload example interrupts an upload after the first chunk like a dropped connection would, then resumes it through the public SDK method. The lifecycle example now polls the Assembly list briefly because the API acknowledges creation before the list storage row lands. Co-Authored-By: Claude Fable 5 --- .../api2-devdock-assembly-lifecycle/main.py | 18 +- .../api2-devdock-tus-resume-upload/main.py | 203 ++++++++++++++++++ transloadit/async_client.py | 53 +++++ transloadit/client.py | 51 +++++ 4 files changed, 324 insertions(+), 1 deletion(-) create mode 100644 examples/api2-devdock-tus-resume-upload/main.py diff --git a/examples/api2-devdock-assembly-lifecycle/main.py b/examples/api2-devdock-assembly-lifecycle/main.py index 219441a..2c66790 100644 --- a/examples/api2-devdock-assembly-lifecycle/main.py +++ b/examples/api2-devdock-assembly-lifecycle/main.py @@ -8,6 +8,7 @@ import json import os from pathlib import Path +from time import sleep from transloadit.client import Transloadit @@ -115,6 +116,8 @@ def main(): client.get_assembly(assembly_url=assembly_url), "getAssemblyStatus", ) + # The Assembly list is eventually consistent: the API acknowledges creation before + # the list storage row lands, so poll briefly until the created Assembly shows up. listed = response_data( client.list_assemblies( { @@ -124,8 +127,21 @@ def main(): ), "listAssemblies", ) - listed_items = list_items(listed) + for _attempt in range(20): + if any(item_assembly_id(item) == assembly_id for item in listed_items): + break + sleep(0.5) + listed = response_data( + client.list_assemblies( + { + "assembly_id": assembly_id, + "pagesize": scenario["list"]["pageSize"], + } + ), + "listAssemblies", + ) + listed_items = list_items(listed) cancelled = response_data( client.cancel_assembly(assembly_url=assembly_url), "cancelAssembly", diff --git a/examples/api2-devdock-tus-resume-upload/main.py b/examples/api2-devdock-tus-resume-upload/main.py new file mode 100644 index 0000000..1621f2e --- /dev/null +++ b/examples/api2-devdock-tus-resume-upload/main.py @@ -0,0 +1,203 @@ +"""Run the API2 contract TUS resume scenario against a devdock API2 server. + +This example is intentionally checked into the SDK repository: it reads the +API/TUS facts from API2's injected scenario JSON, interrupts an upload like an +unlucky user would, and resumes it through the public SDK method. +""" + +import base64 +import json +import os +from pathlib import Path +from urllib.parse import urljoin + +import requests + +from transloadit.client import Transloadit + + +def required_env(name): + value = os.environ.get(name) + if not value: + raise RuntimeError(f"{name} must be set") + return value + + +def fail(message): + raise RuntimeError(message) + + +def load_scenario(): + configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") + scenario_path = ( + Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") + ) + with scenario_path.open(encoding="utf-8") as scenario_file: + return json.load(scenario_file) + + +def response_data(response, operation): + data = response.data + if not isinstance(data, dict): + fail(f"{operation} returned non-JSON data: {data!r}") + if data.get("error"): + fail(f"{operation} returned {data.get('error')}: {data.get('message')}") + return data + + +def resolve_value(value_spec, context, label): + if not isinstance(value_spec, dict): + fail(f"{label} value spec must be an object") + if "value" in value_spec: + return value_spec["value"] + + source = value_spec.get("source") + if not isinstance(source, dict): + fail(f"{label} value spec has no literal value or source") + root = source.get("root") + if not isinstance(root, str) or root not in context: + fail(f"{label} value source root is unavailable") + current = context[root] + for part in source.get("path", []): + if not isinstance(current, dict) or part not in current: + fail(f"{label} value source cannot read {part}") + current = current[part] + return current + + +def scenario_bytes(upload): + source = upload.get("source") + if not isinstance(source, dict) or source.get("kind") != "bytes": + fail("upload.source.kind must be bytes") + if source.get("encoding") != "utf8": + fail("upload.source.encoding must be utf8") + return str(source["value"]).encode("utf-8") + + +def upload_metadata(upload, context): + metadata = {} + for field in upload.get("metadata", []): + metadata[field["name"]] = str(resolve_value(field["value"], context, field["name"])) + return metadata + + +def create_interrupted_upload(tus_url, content, metadata, stop_after_accepted_bytes): + """Create a TUS upload and only send the first chunk, leaving the upload + interrupted the way a dropped connection would.""" + metadata_parts = [] + for name, value in metadata.items(): + encoded_value = base64.b64encode(value.encode("utf-8")).decode("ascii") + metadata_parts.append(f"{name} {encoded_value}") + + create_response = requests.post( + tus_url, + data=b"", + headers={ + "Tus-Resumable": "1.0.0", + "Upload-Length": str(len(content)), + "Upload-Metadata": ",".join(metadata_parts), + }, + timeout=60, + ) + if create_response.status_code != 201: + fail(f"TUS create returned HTTP {create_response.status_code}, expected 201") + location = create_response.headers.get("Location") + if not location: + fail("TUS create did not return a Location header") + upload_url = urljoin(tus_url, location) + + patch_response = requests.patch( + upload_url, + data=content[:stop_after_accepted_bytes], + headers={ + "Tus-Resumable": "1.0.0", + "Upload-Offset": "0", + "Content-Type": "application/offset+octet-stream", + }, + timeout=60, + ) + if patch_response.status_code != 204: + fail(f"TUS first chunk returned HTTP {patch_response.status_code}, expected 204") + accepted_bytes = int(patch_response.headers.get("Upload-Offset", "-1")) + if accepted_bytes != stop_after_accepted_bytes: + fail( + f"TUS first chunk accepted {accepted_bytes} bytes, " + f"expected {stop_after_accepted_bytes}" + ) + + return upload_url + + +def write_result(result): + result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") + if not result_path: + return + + with Path(result_path).open("w", encoding="utf-8") as result_file: + json.dump(result, result_file, indent=2) + result_file.write("\n") + + +def main(): + scenario = load_scenario() + endpoint = required_env("TRANSLOADIT_ENDPOINT") + client = Transloadit( + auth_key=required_env("TRANSLOADIT_KEY"), + auth_secret=required_env("TRANSLOADIT_SECRET"), + service=endpoint, + ) + + create_response = scenario.get("prepared", {}).get("createResponse") + if not isinstance(create_response, dict): + fail("prepared.createResponse must be an object") + upload = scenario.get("upload") + if not isinstance(upload, dict): + fail("upload must be an object") + resume = upload.get("resume") + if not isinstance(resume, dict): + fail("upload.resume must be an object") + + context = {"createResponse": create_response, "scenario": scenario} + content = scenario_bytes(upload) + tus_url = str(resolve_value(upload["tusUrl"], context, "upload.tusUrl")) + metadata = upload_metadata(upload, context) + + first_upload_url = create_interrupted_upload( + tus_url, + content, + metadata, + resume["stopAfterAcceptedBytes"], + ) + + # Remember the interrupted upload by fingerprint, like a TUS client URL storage would. + stored_uploads = {resume["fingerprint"]: first_upload_url} + previous_upload_count = len(stored_uploads) + + completed_assembly = client.resume_tus_upload( + stored_uploads[resume["fingerprint"]], + content, + create_response["assembly_ssl_url"], + ) + response_data(completed_assembly, "resumeTusUpload") + + if resume["removeFingerprintOnSuccess"]: + del stored_uploads[resume["fingerprint"]] + remaining_previous_upload_count = len(stored_uploads) + + write_result( + { + "firstUploadUrl": first_upload_url, + "previousUploadCount": previous_upload_count, + "remainingPreviousUploadCount": remaining_previous_upload_count, + "uploadUrl": first_upload_url, + } + ) + + print( + "Python Transloadit SDK devdock scenario " + f"{scenario['exampleInput']['scenarioId']} resumed {first_upload_url}" + ) + + +if __name__ == "__main__": + main() diff --git a/transloadit/async_client.py b/transloadit/async_client.py index ebf545d..7be018e 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -268,6 +268,59 @@ async def create_tus_assembly(self, file_count: int): return assembly + async def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): + """ + Resumes an interrupted TUS upload from the server-reported offset and waits for the Assembly to finish. + """ + stored_upload_url = upload_url + if not stored_upload_url: + raise RuntimeError("TUS resumeUpload needs input.storedUploadUrl") + + session = await self.request._ensure_session() + + offset_headers = {} + offset_headers["Tus-Resumable"] = "1.0.0" + async with session.request( + "HEAD", + stored_upload_url, + data=b"", + headers=offset_headers, + timeout=self.request._timeout(), + ) as offset_response: + if offset_response.status != 200: + raise RuntimeError(f"TUS offset returned HTTP {offset_response.status}, expected 200") + resume_offset_header = offset_response.headers.get("Upload-Offset") + if not resume_offset_header: + raise RuntimeError("TUS offset did not return a Upload-Offset header") + try: + resume_offset = int(resume_offset_header) + except ValueError as error: + raise RuntimeError("TUS offset returned an invalid Upload-Offset header") from error + + upload_headers = {} + upload_headers["Tus-Resumable"] = "1.0.0" + upload_headers["Upload-Offset"] = str(resume_offset) + upload_headers["Content-Type"] = "application/offset+octet-stream" + async with session.request( + "PATCH", + stored_upload_url, + data=content[resume_offset:], + headers=upload_headers, + timeout=self.request._timeout(), + ) as upload_response: + if upload_response.status != 204: + raise RuntimeError(f"TUS upload returned HTTP {upload_response.status}, expected 204") + try: + upload_offset = int(upload_response.headers.get("Upload-Offset", "")) + except ValueError as error: + raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error + if upload_offset != len(content): + raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") + + completed_assembly = await self.wait_for_assembly(assembly_ssl_url) + + return completed_assembly + async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. diff --git a/transloadit/client.py b/transloadit/client.py index 1dc9e4d..3328623 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -278,6 +278,57 @@ def create_tus_assembly(self, file_count: int): return assembly + def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): + """ + Resumes an interrupted TUS upload from the server-reported offset and waits for the Assembly to finish. + """ + stored_upload_url = upload_url + if not stored_upload_url: + raise RuntimeError("TUS resumeUpload needs input.storedUploadUrl") + + offset_headers = {} + offset_headers["Tus-Resumable"] = "1.0.0" + offset_response = requests.request( + "HEAD", + stored_upload_url, + data=b"", + headers=offset_headers, + timeout=request.TIMEOUT, + ) + if offset_response.status_code != 200: + raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}, expected 200") + resume_offset_header = offset_response.headers.get("Upload-Offset") + if not resume_offset_header: + raise RuntimeError("TUS offset did not return a Upload-Offset header") + try: + resume_offset = int(resume_offset_header) + except ValueError as error: + raise RuntimeError("TUS offset returned an invalid Upload-Offset header") from error + + upload_headers = {} + upload_headers["Tus-Resumable"] = "1.0.0" + upload_headers["Upload-Offset"] = str(resume_offset) + upload_headers["Content-Type"] = "application/offset+octet-stream" + upload_response = requests.request( + "PATCH", + stored_upload_url, + data=content[resume_offset:], + headers=upload_headers, + timeout=request.TIMEOUT, + ) + if upload_response.status_code != 204: + raise RuntimeError(f"TUS upload returned HTTP {upload_response.status_code}, expected 204") + try: + upload_offset = int(upload_response.headers.get("Upload-Offset", "")) + except ValueError as error: + raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error + if upload_offset != len(content): + raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") + + completed_assembly = self.wait_for_assembly(assembly_ssl_url) + + return completed_assembly + def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. From 846f1b7043218f7faefd0b948258c7bc922ac1b9 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 02:24:18 +0200 Subject: [PATCH 47/64] Refresh generated endpoint documentation --- transloadit/async_client.py | 14 +++++++------- transloadit/client.py | 14 +++++++------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 7be018e..24b3795 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -63,7 +63,7 @@ async def create_assembly(self, data: Optional[dict] = None, extra_data: Optiona async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ - Create Assembly With Id. + Create an Assembly with a chosen ID. """ assembly_id = require_path_id(assembly_id, "assembly_id") @@ -113,7 +113,7 @@ async def replay_assembly_notification(self, assembly_id: str, data: Optional[di async def list_assembly_notifications(self, assembly_id: str): """ - List Assembly Notifications. + Retrieve Assembly Notifications. """ assembly_id = require_path_id(assembly_id, "assembly_id") @@ -147,7 +147,7 @@ async def get_template(self, template_id: str, params: Optional[dict] = None): async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Get Builtin Template. + Retrieve a built-in Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") @@ -155,7 +155,7 @@ async def get_builtin_template(self, builtin_template_slug: str, params: Optiona async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Get Template Full. + Retrieve full Template details. """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") @@ -163,7 +163,7 @@ async def get_template_full(self, template_id_or_name: str, params: Optional[dic async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Get Builtin Template Full. + Retrieve full built-in Template details. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") @@ -199,13 +199,13 @@ async def list_template_credentials(self, params: Optional[dict] = None): async def list_template_credential_types(self, params: Optional[dict] = None): """ - List Template Credential Types. + Retrieve Template Credential types. """ return await self.request.get("/template_credentials/types", params=params) async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): """ - Validate Template Credential OAuth On Create. + Validate an OAuth Template Credential name. """ return await self.request.post("/template_credentials/validateOauthOnCreate", data=data) diff --git a/transloadit/client.py b/transloadit/client.py index 3328623..39892cc 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -73,7 +73,7 @@ def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ - Create Assembly With Id. + Create an Assembly with a chosen ID. """ assembly_id = require_path_id(assembly_id, "assembly_id") @@ -123,7 +123,7 @@ def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = def list_assembly_notifications(self, assembly_id: str): """ - List Assembly Notifications. + Retrieve Assembly Notifications. """ assembly_id = require_path_id(assembly_id, "assembly_id") @@ -157,7 +157,7 @@ def get_template(self, template_id: str, params: Optional[dict] = None): def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Get Builtin Template. + Retrieve a built-in Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") @@ -165,7 +165,7 @@ def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Get Template Full. + Retrieve full Template details. """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") @@ -173,7 +173,7 @@ def get_template_full(self, template_id_or_name: str, params: Optional[dict] = N def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Get Builtin Template Full. + Retrieve full built-in Template details. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") @@ -209,13 +209,13 @@ def list_template_credentials(self, params: Optional[dict] = None): def list_template_credential_types(self, params: Optional[dict] = None): """ - List Template Credential Types. + Retrieve Template Credential types. """ return self.request.get("/template_credentials/types", params=params) def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): """ - Validate Template Credential OAuth On Create. + Validate an OAuth Template Credential name. """ return self.request.post("/template_credentials/validateOauthOnCreate", data=data) From 7d0d02e193df2d2e4d5719bfbad0ab6b1409f666 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 03:55:02 +0200 Subject: [PATCH 48/64] Generate bearer token issuance --- tests/test_async_client.py | 21 +++++++++++++++ tests/test_client.py | 29 ++++++++++++++++++++ transloadit/async_client.py | 54 +++++++++++++++++++++++++++++++++++++ transloadit/client.py | 49 +++++++++++++++++++++++++++++++++ 4 files changed, 153 insertions(+) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index cc59eea..8fd1b6b 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -282,6 +282,27 @@ async def asyncSetUp(self): async def asyncTearDown(self): await self.server.close() + async def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self): + session = _RecordingSession({ + "access_token": "abc", + "expires_in": 21600, + "scope": "assemblies:read", + "token_type": "Bearer", + }) + client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) + + response = await client.issue_bearer_token({"scope": "assemblies:read"}) + + self.assertEqual(response.data["access_token"], "abc") + url, kwargs = session.calls[0] + self.assertEqual(url, f"{self.server.base_url}/token") + self.assertEqual( + kwargs["data"], + {"grant_type": "client_credentials", "scope": "assemblies:read"}, + ) + self.assertEqual(kwargs["headers"]["Authorization"], "Basic a2V5OnNlY3JldA==") + self.assertFalse(kwargs["allow_redirects"]) + async def test_async_client_methods_and_context_manager(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.get_assembly(assembly_id="abc123") diff --git a/tests/test_client.py b/tests/test_client.py index 824fc97..50c5262 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -78,6 +78,35 @@ def test_get_assembly(self, mock): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abcdef12345") + @requests_mock.Mocker() + def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self, requests_mock): + requests_mock.post( + f"{self.transloadit.service}/token", + json={ + "access_token": "abc", + "expires_in": 21600, + "scope": "assemblies:read", + "token_type": "Bearer", + }, + ) + + response = self.transloadit.issue_bearer_token({"scope": "assemblies:read"}) + + self.assertEqual(response.data["access_token"], "abc") + request = requests_mock.request_history[0] + self.assertEqual(request.headers["Authorization"], "Basic a2V5OnNlY3JldA==") + self.assertEqual( + request.headers["Content-Type"], + "application/x-www-form-urlencoded", + ) + self.assertEqual( + urllib.parse.parse_qs(request.text), + { + "grant_type": ["client_credentials"], + "scope": ["assemblies:read"], + }, + ) + def test_wait_for_assembly_polls_until_terminal(self): responses = [ Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 24b3795..5c8261e 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -191,6 +191,60 @@ async def list_priority_job_slots(self, params: Optional[dict] = None): """ return await self.request.get("/queues/job_slots", params=params) + async def issue_bearer_token(self, data: Optional[dict] = None): + """ + Create a bearer token. + """ + if not self.auth_secret: + raise ValueError("Bearer token issuance requires an auth secret.") + + from urllib.parse import urlparse + + endpoint = urlparse(self.service) + loopback = ( + endpoint.hostname in ("localhost", "::1") + or (endpoint.hostname or "").startswith("127.") + ) + if ( + endpoint.username is not None + or endpoint.password is not None + or not (endpoint.scheme == "https" or (endpoint.scheme == "http" and loopback)) + ): + raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") + + data = data or {} + form_data = {} + if data.get("aud") is not None: + form_data["aud"] = data["aud"] + form_data["grant_type"] = "client_credentials" + if data.get("scope") is not None: + form_data["scope"] = data["scope"] + + credentials = base64.b64encode( + f"{self.auth_key}:{self.auth_secret}".encode("utf-8") + ).decode("ascii") + headers = { + "Accept": "application/json", + "Authorization": f"Basic {credentials}", + "Content-Type": "application/x-www-form-urlencoded", + } + headers.update(self.request._headers()) + session = await self.request._ensure_session() + async with session.post( + self.service + "/token", + data=form_data, + headers=headers, + timeout=self.request._timeout(), + allow_redirects=False, + ) as raw_response: + from .response import Response + + return Response( + data=await self.request._read_response_data(raw_response), + status_code=raw_response.status, + headers=raw_response.headers, + ) + async def list_template_credentials(self, params: Optional[dict] = None): """ Retrieve list of Template Credentials. diff --git a/transloadit/client.py b/transloadit/client.py index 39892cc..dbaedb2 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -201,6 +201,55 @@ def list_priority_job_slots(self, params: Optional[dict] = None): """ return self.request.get("/queues/job_slots", params=params) + def issue_bearer_token(self, data: Optional[dict] = None): + """ + Create a bearer token. + """ + if not self.auth_secret: + raise ValueError("Bearer token issuance requires an auth secret.") + + from urllib.parse import urlparse + + endpoint = urlparse(self.service) + loopback = ( + endpoint.hostname in ("localhost", "::1") + or (endpoint.hostname or "").startswith("127.") + ) + if ( + endpoint.username is not None + or endpoint.password is not None + or not (endpoint.scheme == "https" or (endpoint.scheme == "http" and loopback)) + ): + raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") + + data = data or {} + form_data = {} + if data.get("aud") is not None: + form_data["aud"] = data["aud"] + form_data["grant_type"] = "client_credentials" + if data.get("scope") is not None: + form_data["scope"] = data["scope"] + + credentials = base64.b64encode( + f"{self.auth_key}:{self.auth_secret}".encode("utf-8") + ).decode("ascii") + headers = { + "Accept": "application/json", + "Authorization": f"Basic {credentials}", + "Content-Type": "application/x-www-form-urlencoded", + } + headers.update(self.request.HEADERS) + raw_response = requests.post( + self.service + "/token", + data=form_data, + headers=headers, + timeout=request.TIMEOUT, + allow_redirects=False, + ) + from .response import Response + + return Response(raw_response) + def list_template_credentials(self, params: Optional[dict] = None): """ Retrieve list of Template Credentials. From 91fdb4ba5500d1d69547e4059034c8f847951a87 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 10:07:55 +0200 Subject: [PATCH 49/64] Harden generated bearer token endpoints --- tests/test_async_client.py | 13 ++++++++++++ tests/test_client.py | 7 +++++++ transloadit/async_client.py | 41 ++++++++++++++++++++----------------- transloadit/client.py | 41 ++++++++++++++++++++----------------- 4 files changed, 64 insertions(+), 38 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 8fd1b6b..22f2257 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -303,6 +303,19 @@ async def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self): self.assertEqual(kwargs["headers"]["Authorization"], "Basic a2V5OnNlY3JldA==") self.assertFalse(kwargs["allow_redirects"]) + async def test_issue_bearer_token_rejects_127_prefixed_domain(self): + session = _RecordingSession({}) + client = AsyncTransloadit( + "key", + "secret", + service="http://127.attacker.com", + session=session, + ) + + with self.assertRaisesRegex(ValueError, "insecure bearer token endpoint"): + await client.issue_bearer_token() + self.assertEqual(session.calls, []) + async def test_async_client_methods_and_context_manager(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.get_assembly(assembly_id="abc123") diff --git a/tests/test_client.py b/tests/test_client.py index 50c5262..797eb1d 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -107,6 +107,13 @@ def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self, requests_moc }, ) + def test_issue_bearer_token_rejects_127_prefixed_domain(self): + client = Transloadit("key", "secret", service="http://127.attacker.com") + with mock.patch("transloadit.client.requests.post") as post_mock: + with self.assertRaisesRegex(ValueError, "insecure bearer token endpoint"): + client.issue_bearer_token() + post_mock.assert_not_called() + def test_wait_for_assembly_polls_until_terminal(self): responses = [ Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 5c8261e..38a61ec 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -137,37 +137,37 @@ async def create_template(self, data: Optional[dict] = None): """ return await self.request.post("/templates", data=data) - async def get_template(self, template_id: str, params: Optional[dict] = None): + async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Retrieve a Template. + Retrieve full Template details. """ - template_id = require_path_id(template_id, "template_id") + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return await self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) + return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) - async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Retrieve a built-in Template. + Retrieve full built-in Template details. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) - async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): + async def get_template(self, template_id: str, params: Optional[dict] = None): """ - Retrieve full Template details. + Retrieve a Template. """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + template_id = require_path_id(template_id, "template_id") - return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) + return await self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) - async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): + async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Retrieve full built-in Template details. + Retrieve a built-in Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) + return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) async def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -198,13 +198,16 @@ async def issue_bearer_token(self, data: Optional[dict] = None): if not self.auth_secret: raise ValueError("Bearer token issuance requires an auth secret.") + from ipaddress import ip_address from urllib.parse import urlparse endpoint = urlparse(self.service) - loopback = ( - endpoint.hostname in ("localhost", "::1") - or (endpoint.hostname or "").startswith("127.") - ) + try: + loopback = endpoint.hostname == "localhost" or ip_address( + endpoint.hostname or "" + ).is_loopback + except ValueError: + loopback = False if ( endpoint.username is not None or endpoint.password is not None @@ -231,7 +234,7 @@ async def issue_bearer_token(self, data: Optional[dict] = None): headers.update(self.request._headers()) session = await self.request._ensure_session() async with session.post( - self.service + "/token", + self.service.rstrip("/") + "/token", data=form_data, headers=headers, timeout=self.request._timeout(), diff --git a/transloadit/client.py b/transloadit/client.py index dbaedb2..e24e350 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -147,37 +147,37 @@ def create_template(self, data: Optional[dict] = None): """ return self.request.post("/templates", data=data) - def get_template(self, template_id: str, params: Optional[dict] = None): + def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Retrieve a Template. + Retrieve full Template details. """ - template_id = require_path_id(template_id, "template_id") + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) + return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) - def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Retrieve a built-in Template. + Retrieve full built-in Template details. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) - def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): + def get_template(self, template_id: str, params: Optional[dict] = None): """ - Retrieve full Template details. + Retrieve a Template. """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + template_id = require_path_id(template_id, "template_id") - return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) + return self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) - def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): + def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Retrieve full built-in Template details. + Retrieve a built-in Template. """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) + return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -208,13 +208,16 @@ def issue_bearer_token(self, data: Optional[dict] = None): if not self.auth_secret: raise ValueError("Bearer token issuance requires an auth secret.") + from ipaddress import ip_address from urllib.parse import urlparse endpoint = urlparse(self.service) - loopback = ( - endpoint.hostname in ("localhost", "::1") - or (endpoint.hostname or "").startswith("127.") - ) + try: + loopback = endpoint.hostname == "localhost" or ip_address( + endpoint.hostname or "" + ).is_loopback + except ValueError: + loopback = False if ( endpoint.username is not None or endpoint.password is not None @@ -240,7 +243,7 @@ def issue_bearer_token(self, data: Optional[dict] = None): } headers.update(self.request.HEADERS) raw_response = requests.post( - self.service + "/token", + self.service.rstrip("/") + "/token", data=form_data, headers=headers, timeout=request.TIMEOUT, From 4873622d0a8269c0a6087299932091aa28b89469 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 13:10:26 +0200 Subject: [PATCH 50/64] Generate invoice bill endpoint --- transloadit/async_client.py | 9 +++++++++ transloadit/client.py | 9 +++++++++ 2 files changed, 18 insertions(+) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 38a61ec..a23e3db 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -125,6 +125,15 @@ async def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ return await self.request.get(f"/bill/{year}-{month:02d}", params=params) + async def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): + """ + Retrieve an invoice’s bill. + """ + date = require_path_id(date, "date") + invoice_id = require_path_id(invoice_id, "invoice_id") + + return await self.request.get(f"/bill/{_quote_path_segment(date)}/{_quote_path_segment(invoice_id)}", params=params) + async def list_templates(self, params: Optional[dict] = None): """ Retrieve list of Templates. diff --git a/transloadit/client.py b/transloadit/client.py index e24e350..b81b3df 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -135,6 +135,15 @@ def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ return self.request.get(f"/bill/{year}-{month:02d}", params=params) + def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): + """ + Retrieve an invoice’s bill. + """ + date = require_path_id(date, "date") + invoice_id = require_path_id(invoice_id, "invoice_id") + + return self.request.get(f"/bill/{_quote_path_segment(date)}/{_quote_path_segment(invoice_id)}", params=params) + def list_templates(self, params: Optional[dict] = None): """ Retrieve list of Templates. From e679c33812d9f7f1d32f2688c5d0c287e9d85804 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 14:56:35 +0200 Subject: [PATCH 51/64] Generate exact-one-file TUS helper --- examples/api2-devdock-tus-assembly/main.py | 1 - transloadit/async_client.py | 4 ++-- transloadit/client.py | 4 ++-- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py index 7e68dc0..af956ba 100644 --- a/examples/api2-devdock-tus-assembly/main.py +++ b/examples/api2-devdock-tus-assembly/main.py @@ -113,7 +113,6 @@ def main(): input_values = upload_tus_assembly_input(example_input_values) upload = upload_config(input_values) completed_assembly, upload_url = client.upload_tus_assembly( - input_values["file_count"], upload["content"], upload["fieldname"], upload["filename"], diff --git a/transloadit/async_client.py b/transloadit/async_client.py index a23e3db..411a094 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -387,11 +387,11 @@ async def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_ return completed_assembly - async def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): + async def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ - created_assembly = await self.create_tus_assembly(file_count) + created_assembly = await self.create_tus_assembly(1) endpoint_url = created_assembly.data.get("tus_url") if not endpoint_url: diff --git a/transloadit/client.py b/transloadit/client.py index b81b3df..91eb687 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -390,11 +390,11 @@ def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: s return completed_assembly - def upload_tus_assembly(self, file_count: int, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): + def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """ Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. """ - created_assembly = self.create_tus_assembly(file_count) + created_assembly = self.create_tus_assembly(1) endpoint_url = created_assembly.data.get("tus_url") if not endpoint_url: From 9ca0ce4b411180dd0cccddf87a91a618d053d102 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 11 Jul 2026 20:16:44 +0200 Subject: [PATCH 52/64] Harden generated Assembly URL requests --- tests/test_async_client.py | 27 +++++++++-------- tests/test_client.py | 43 +++++++++++++++++++++----- transloadit/async_client.py | 60 +++++++++++++++++++++++++++++++++++-- transloadit/client.py | 55 ++++++++++++++++++++++++++++++++-- 4 files changed, 161 insertions(+), 24 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 22f2257..77fd897 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -250,6 +250,10 @@ def put(self, url, **kwargs): self.calls.append((url, kwargs)) return _FakeResponseContext(self.payload) + def request(self, method, url, **kwargs): + self.calls.append((url, kwargs)) + return _FakeResponseContext(self.payload) + async def close(self): self.closed = True @@ -410,17 +414,10 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): service="https://api2.transloadit.com", session=external_session, ) - await external_client.get_assembly(assembly_url="https://example.com/assemblies/abc123") - await external_client.cancel_assembly(assembly_url="https://example.com/assemblies/abc123") - self.assertEqual( - [call[0] for call in external_session.calls], - [ - "https://example.com/assemblies/abc123", - "https://example.com/assemblies/abc123", - ], - ) - self.assertIsNone(external_session.calls[0][1]["params"]) - self.assertEqual(external_session.calls[1][1]["data"], []) + for method in (external_client.get_assembly, external_client.cancel_assembly): + with self.assertRaisesRegex(ValueError, "untrusted Assembly URL"): + await method(assembly_url="https://example.com/assemblies/abc123") + self.assertEqual(external_session.calls, []) transloadit_session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) transloadit_client = AsyncTransloadit( @@ -430,13 +427,17 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): session=transloadit_session, ) await transloadit_client.get_assembly( - assembly_url="https://api2-region.transloadit.com/assemblies/abc123" + assembly_url="https://api2-region.transloadit.com/assemblies/abc123", + params={"nonce": 123}, ) self.assertEqual( transloadit_session.calls[0][0], "https://api2-region.transloadit.com/assemblies/abc123", ) - self.assertIn("signature", transloadit_session.calls[0][1]["params"]) + request_kwargs = transloadit_session.calls[0][1] + self.assertEqual(request_kwargs["params"], {"nonce": 123}) + self.assertNotIn("Authorization", request_kwargs["headers"]) + self.assertFalse(request_kwargs["allow_redirects"]) await client.close() diff --git a/tests/test_client.py b/tests/test_client.py index 797eb1d..dcc40bf 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -78,6 +78,33 @@ def test_get_assembly(self, mock): self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(response.data["assembly_id"], "abcdef12345") + def test_assembly_urls_are_trusted_and_unauthenticated(self): + with mock.patch("transloadit.client.requests.request") as request_mock: + for method in (self.transloadit.get_assembly, self.transloadit.cancel_assembly): + with self.assertRaisesRegex(ValueError, "untrusted Assembly URL"): + method(assembly_url="https://example.com/assemblies/abc123") + request_mock.assert_not_called() + + raw_response = mock.Mock() + raw_response.json.return_value = {"ok": "ASSEMBLY_COMPLETED"} + with mock.patch( + "transloadit.client.requests.request", + return_value=raw_response, + ) as request_mock: + self.transloadit.get_assembly( + assembly_url="https://api2-region.transloadit.com/assemblies/abc123", + params={"nonce": 123}, + ) + + request_mock.assert_called_once() + method, url = request_mock.call_args.args + request_kwargs = request_mock.call_args.kwargs + self.assertEqual(method, "GET") + self.assertEqual(url, "https://api2-region.transloadit.com/assemblies/abc123") + self.assertEqual(request_kwargs["params"], {"nonce": 123}) + self.assertNotIn("Authorization", request_kwargs["headers"]) + self.assertFalse(request_kwargs["allow_redirects"]) + @requests_mock.Mocker() def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self, requests_mock): requests_mock.post( @@ -170,16 +197,18 @@ def test_create_tus_assembly_uses_contract_payload(self): ) def test_quotes_path_ids(self): - with mock.patch.object(self.transloadit.request, 'get') as get_mock: - self.transloadit.get_assembly(assembly_id='assembly/with?chars') - self.transloadit.get_template('template/with?chars') + with mock.patch.object(self.transloadit, '_request_assembly_url') as assembly_mock: + with mock.patch.object(self.transloadit.request, 'get') as get_mock: + self.transloadit.get_assembly(assembly_id='assembly/with?chars') + self.transloadit.get_template('template/with?chars') self.assertEqual( get_mock.call_args_list, - [ - mock.call('/assemblies/assembly%2Fwith%3Fchars', params=None), - mock.call('/templates/template%2Fwith%3Fchars', params=None), - ], + [mock.call('/templates/template%2Fwith%3Fchars', params=None)], + ) + self.assertEqual( + assembly_mock.call_args_list, + [mock.call('/assemblies/assembly%2Fwith%3Fchars', 'GET', params=None)], ) def test_rejects_empty_template_ids(self): diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 411a094..5d2c2d9 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -55,6 +55,62 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + async def _request_assembly_url(self, url, method, params=None): + from urllib.parse import urlparse + + if "://" in url and not url.startswith(("http://", "https://")): + raise ValueError("Invalid Assembly URL.") + candidate_url = ( + url + if url.startswith(("http://", "https://")) + else self.service.rstrip("/") + "/" + url.lstrip("/") + ) + try: + candidate = urlparse(candidate_url) + configured = urlparse(self.service) + candidate_port = candidate.port or (443 if candidate.scheme == "https" else 80) + configured_port = configured.port or (443 if configured.scheme == "https" else 80) + except ValueError as error: + raise ValueError("Invalid Assembly URL.") from error + + candidate_hostname = (candidate.hostname or "").lower() + configured_hostname = (configured.hostname or "").lower() + has_url_credentials = candidate.username is not None or candidate.password is not None + configured_origin = ( + not has_url_credentials + and candidate.scheme == configured.scheme + and candidate_hostname == configured_hostname + and candidate_port == configured_port + ) + api2_cell = ( + not has_url_credentials + and candidate.scheme == "https" + and candidate_port == 443 + and candidate_hostname.startswith("api2-") + and candidate_hostname.endswith(".transloadit.com") + ) + if not (configured_origin or api2_cell): + raise ValueError("Refusing to request an untrusted Assembly URL.") + if method not in {"GET", "DELETE"}: + raise ValueError(f"Unsupported Assembly URL method: {method}") + + session = await self.request._ensure_session() + async with session.request( + method, + candidate_url, + params=params, + headers=self.request._headers(), + timeout=self.request._timeout(), + allow_redirects=False, + ) as raw_response: + from .response import Response + + return Response( + data=await self.request._read_response_data(raw_response), + status_code=raw_response.status, + headers=raw_response.headers, + ) + async def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. @@ -83,7 +139,7 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None, raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return await self.request.get(url, params=params) + return await self._request_assembly_url(url, "GET", params=params) async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ @@ -93,7 +149,7 @@ async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = Non raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return await self.request.delete(url) + return await self._request_assembly_url(url, "DELETE") async def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): """ diff --git a/transloadit/client.py b/transloadit/client.py index 91eb687..b032a53 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -65,6 +65,57 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + def _request_assembly_url(self, url, method, params=None): + from urllib.parse import urlparse + + if "://" in url and not url.startswith(("http://", "https://")): + raise ValueError("Invalid Assembly URL.") + candidate_url = ( + url + if url.startswith(("http://", "https://")) + else self.service.rstrip("/") + "/" + url.lstrip("/") + ) + try: + candidate = urlparse(candidate_url) + configured = urlparse(self.service) + candidate_port = candidate.port or (443 if candidate.scheme == "https" else 80) + configured_port = configured.port or (443 if configured.scheme == "https" else 80) + except ValueError as error: + raise ValueError("Invalid Assembly URL.") from error + + candidate_hostname = (candidate.hostname or "").lower() + configured_hostname = (configured.hostname or "").lower() + has_url_credentials = candidate.username is not None or candidate.password is not None + configured_origin = ( + not has_url_credentials + and candidate.scheme == configured.scheme + and candidate_hostname == configured_hostname + and candidate_port == configured_port + ) + api2_cell = ( + not has_url_credentials + and candidate.scheme == "https" + and candidate_port == 443 + and candidate_hostname.startswith("api2-") + and candidate_hostname.endswith(".transloadit.com") + ) + if not (configured_origin or api2_cell): + raise ValueError("Refusing to request an untrusted Assembly URL.") + if method not in {"GET", "DELETE"}: + raise ValueError(f"Unsupported Assembly URL method: {method}") + + raw_response = requests.request( + method, + candidate_url, + params=params, + headers=request.Request.HEADERS, + timeout=request.TIMEOUT, + allow_redirects=False, + ) + from .response import Response + + return Response(raw_response) + def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create a new Assembly. @@ -93,7 +144,7 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return self.request.get(url, params=params) + return self._request_assembly_url(url, "GET", params=params) def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ @@ -103,7 +154,7 @@ def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" - return self.request.delete(url) + return self._request_assembly_url(url, "DELETE") def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): """ From 6c015fe36be97f19cf1b68b9addb260de969ee03 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 12 Jul 2026 06:33:42 +0200 Subject: [PATCH 53/64] Allow HTTPS polling on configured hosts --- transloadit/async_client.py | 9 ++++++++- transloadit/client.py | 9 ++++++++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 5d2c2d9..46a8ed5 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -82,6 +82,13 @@ async def _request_assembly_url(self, url, method, params=None): and candidate_hostname == configured_hostname and candidate_port == configured_port ) + configured_https_host = ( + not has_url_credentials + and candidate.scheme == "https" + and candidate_port == 443 + and candidate_hostname != "" + and candidate_hostname == configured_hostname + ) api2_cell = ( not has_url_credentials and candidate.scheme == "https" @@ -89,7 +96,7 @@ async def _request_assembly_url(self, url, method, params=None): and candidate_hostname.startswith("api2-") and candidate_hostname.endswith(".transloadit.com") ) - if not (configured_origin or api2_cell): + if not (configured_origin or configured_https_host or api2_cell): raise ValueError("Refusing to request an untrusted Assembly URL.") if method not in {"GET", "DELETE"}: raise ValueError(f"Unsupported Assembly URL method: {method}") diff --git a/transloadit/client.py b/transloadit/client.py index b032a53..349e39f 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -92,6 +92,13 @@ def _request_assembly_url(self, url, method, params=None): and candidate_hostname == configured_hostname and candidate_port == configured_port ) + configured_https_host = ( + not has_url_credentials + and candidate.scheme == "https" + and candidate_port == 443 + and candidate_hostname != "" + and candidate_hostname == configured_hostname + ) api2_cell = ( not has_url_credentials and candidate.scheme == "https" @@ -99,7 +106,7 @@ def _request_assembly_url(self, url, method, params=None): and candidate_hostname.startswith("api2-") and candidate_hostname.endswith(".transloadit.com") ) - if not (configured_origin or api2_cell): + if not (configured_origin or configured_https_host or api2_cell): raise ValueError("Refusing to request an untrusted Assembly URL.") if method not in {"GET", "DELETE"}: raise ValueError(f"Unsupported Assembly URL method: {method}") From 4c15f0c9743b6ec24ee059dc2149d7f59ba1978a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 12 Jul 2026 08:44:43 +0200 Subject: [PATCH 54/64] Reject dot path segments --- tests/test_async_client.py | 4 ++-- tests/test_client.py | 4 ++-- transloadit/async_client.py | 43 ++++++++++++++++++++----------------- transloadit/client.py | 43 ++++++++++++++++++++----------------- 4 files changed, 50 insertions(+), 44 deletions(-) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 77fd897..a4e8576 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -478,11 +478,11 @@ async def test_async_client_quotes_path_ids(self): ], ) - async def test_async_client_rejects_empty_template_ids(self): + async def test_async_client_rejects_invalid_template_ids(self): session = _RecordingSession({"ok": "TEMPLATE_FOUND"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) - for template_id in ("", None): + for template_id in ("", None, ".", ".."): with self.assertRaises(ValueError): await client.get_template(template_id) with self.assertRaises(ValueError): diff --git a/tests/test_client.py b/tests/test_client.py index dcc40bf..fd2eb23 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -211,8 +211,8 @@ def test_quotes_path_ids(self): [mock.call('/assemblies/assembly%2Fwith%3Fchars', 'GET', params=None)], ) - def test_rejects_empty_template_ids(self): - invalid_ids = ("", None) + def test_rejects_invalid_template_ids(self): + invalid_ids = ("", None, ".", "..") with mock.patch.object(self.transloadit.request, "get"): for template_id in invalid_ids: with self.assertRaises(ValueError): diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 46a8ed5..fe9692b 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -8,10 +8,6 @@ from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url -def _quote_path_segment(value: str) -> str: - return quote(str(value), safe="") - - class AsyncTransloadit: """ Asynchronous client interface to the Transloadit API. @@ -55,6 +51,13 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + def _quote_path_segment(self, value: str) -> str: + value = str(value) + if value in (".", ".."): + raise ValueError("Path parameters cannot be dot segments.") + + return quote(value, safe="") + async def _request_assembly_url(self, url, method, params=None): from urllib.parse import urlparse @@ -130,7 +133,7 @@ async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = """ assembly_id = require_path_id(assembly_id, "assembly_id") - return await self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + return await self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) async def list_assemblies(self, params: Optional[dict] = None): """ @@ -145,7 +148,7 @@ async def get_assembly(self, assembly_id: str = None, assembly_url: str = None, if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" return await self._request_assembly_url(url, "GET", params=params) async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): @@ -155,7 +158,7 @@ async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = Non if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" return await self._request_assembly_url(url, "DELETE") async def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): @@ -164,7 +167,7 @@ async def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): """ assembly_id = require_path_id(assembly_id, "assembly_id") - return await self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}/replay", data=data) + return await self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}/replay", data=data) async def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): """ @@ -172,7 +175,7 @@ async def replay_assembly_notification(self, assembly_id: str, data: Optional[di """ assembly_id = require_path_id(assembly_id, "assembly_id") - return await self.request.post(f"/assembly_notifications/{_quote_path_segment(assembly_id)}/replay", data=data) + return await self.request.post(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay", data=data) async def list_assembly_notifications(self, assembly_id: str): """ @@ -180,7 +183,7 @@ async def list_assembly_notifications(self, assembly_id: str): """ assembly_id = require_path_id(assembly_id, "assembly_id") - return await self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + return await self.request.get(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}") async def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ @@ -195,7 +198,7 @@ async def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optiona date = require_path_id(date, "date") invoice_id = require_path_id(invoice_id, "invoice_id") - return await self.request.get(f"/bill/{_quote_path_segment(date)}/{_quote_path_segment(invoice_id)}", params=params) + return await self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) async def list_templates(self, params: Optional[dict] = None): """ @@ -215,7 +218,7 @@ async def get_template_full(self, template_id_or_name: str, params: Optional[dic """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return await self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) + return await self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ @@ -223,7 +226,7 @@ async def get_builtin_template_full(self, builtin_template_slug: str, params: Op """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) + return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) async def get_template(self, template_id: str, params: Optional[dict] = None): """ @@ -231,7 +234,7 @@ async def get_template(self, template_id: str, params: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return await self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) + return await self.request.get(f"/templates/{self._quote_path_segment(template_id)}", params=params) async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ @@ -239,7 +242,7 @@ async def get_builtin_template(self, builtin_template_slug: str, params: Optiona """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return await self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) + return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) async def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -247,7 +250,7 @@ async def update_template(self, template_id: str, data: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return await self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) + return await self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) async def delete_template(self, template_id: str, data: Optional[dict] = None): """ @@ -255,7 +258,7 @@ async def delete_template(self, template_id: str, data: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return await self.request.delete(f"/templates/{_quote_path_segment(template_id)}", data=data) + return await self.request.delete(f"/templates/{self._quote_path_segment(template_id)}", data=data) async def list_priority_job_slots(self, params: Optional[dict] = None): """ @@ -350,7 +353,7 @@ async def get_template_credentials(self, identifier: str, params: Optional[dict] """ identifier = require_path_id(identifier, "identifier") - return await self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}", params=params) + return await self.request.get(f"/template_credentials/{self._quote_path_segment(identifier)}", params=params) async def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): """ @@ -358,7 +361,7 @@ async def delete_template_credentials(self, identifier: str, data: Optional[dict """ identifier = require_path_id(identifier, "identifier") - return await self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + return await self.request.delete(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) async def update_template_credentials(self, identifier: str, data: Optional[dict] = None): """ @@ -366,7 +369,7 @@ async def update_template_credentials(self, identifier: str, data: Optional[dict """ identifier = require_path_id(identifier, "identifier") - return await self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + return await self.request.put(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) # diff --git a/transloadit/client.py b/transloadit/client.py index 349e39f..907bbef 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -14,10 +14,6 @@ from requests import Response -def _quote_path_segment(value: str) -> str: - return quote(str(value), safe="") - - class Transloadit: """ This class serves as a client interface to the Transloadit API. @@ -65,6 +61,13 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: # please report the issue instead of editing this block by hand; the source fix # belongs in the contract generator so all SDKs stay in sync. + def _quote_path_segment(self, value: str) -> str: + value = str(value) + if value in (".", ".."): + raise ValueError("Path parameters cannot be dot segments.") + + return quote(value, safe="") + def _request_assembly_url(self, url, method, params=None): from urllib.parse import urlparse @@ -135,7 +138,7 @@ def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, """ assembly_id = require_path_id(assembly_id, "assembly_id") - return self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) + return self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) def list_assemblies(self, params: Optional[dict] = None): """ @@ -150,7 +153,7 @@ def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" return self._request_assembly_url(url, "GET", params=params) def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): @@ -160,7 +163,7 @@ def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): if not (assembly_id or assembly_url): raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - url = assembly_url if assembly_url else f"/assemblies/{_quote_path_segment(assembly_id)}" + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" return self._request_assembly_url(url, "DELETE") def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): @@ -169,7 +172,7 @@ def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): """ assembly_id = require_path_id(assembly_id, "assembly_id") - return self.request.post(f"/assemblies/{_quote_path_segment(assembly_id)}/replay", data=data) + return self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}/replay", data=data) def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): """ @@ -177,7 +180,7 @@ def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = """ assembly_id = require_path_id(assembly_id, "assembly_id") - return self.request.post(f"/assembly_notifications/{_quote_path_segment(assembly_id)}/replay", data=data) + return self.request.post(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay", data=data) def list_assembly_notifications(self, assembly_id: str): """ @@ -185,7 +188,7 @@ def list_assembly_notifications(self, assembly_id: str): """ assembly_id = require_path_id(assembly_id, "assembly_id") - return self.request.get(f"/assembly_notifications/{_quote_path_segment(assembly_id)}") + return self.request.get(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}") def get_bill(self, month: int, year: int, params: Optional[dict] = None): """ @@ -200,7 +203,7 @@ def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict date = require_path_id(date, "date") invoice_id = require_path_id(invoice_id, "invoice_id") - return self.request.get(f"/bill/{_quote_path_segment(date)}/{_quote_path_segment(invoice_id)}", params=params) + return self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) def list_templates(self, params: Optional[dict] = None): """ @@ -220,7 +223,7 @@ def get_template_full(self, template_id_or_name: str, params: Optional[dict] = N """ template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - return self.request.get(f"/templates/{_quote_path_segment(template_id_or_name)}/full", params=params) + return self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ @@ -228,7 +231,7 @@ def get_builtin_template_full(self, builtin_template_slug: str, params: Optional """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}/full", params=params) + return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) def get_template(self, template_id: str, params: Optional[dict] = None): """ @@ -236,7 +239,7 @@ def get_template(self, template_id: str, params: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return self.request.get(f"/templates/{_quote_path_segment(template_id)}", params=params) + return self.request.get(f"/templates/{self._quote_path_segment(template_id)}", params=params) def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): """ @@ -244,7 +247,7 @@ def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict """ builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - return self.request.get(f"/templates/builtin/{_quote_path_segment(builtin_template_slug)}", params=params) + return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) def update_template(self, template_id: str, data: Optional[dict] = None): """ @@ -252,7 +255,7 @@ def update_template(self, template_id: str, data: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return self.request.put(f"/templates/{_quote_path_segment(template_id)}", data=data) + return self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) def delete_template(self, template_id: str, data: Optional[dict] = None): """ @@ -260,7 +263,7 @@ def delete_template(self, template_id: str, data: Optional[dict] = None): """ template_id = require_path_id(template_id, "template_id") - return self.request.delete(f"/templates/{_quote_path_segment(template_id)}", data=data) + return self.request.delete(f"/templates/{self._quote_path_segment(template_id)}", data=data) def list_priority_job_slots(self, params: Optional[dict] = None): """ @@ -350,7 +353,7 @@ def get_template_credentials(self, identifier: str, params: Optional[dict] = Non """ identifier = require_path_id(identifier, "identifier") - return self.request.get(f"/template_credentials/{_quote_path_segment(identifier)}", params=params) + return self.request.get(f"/template_credentials/{self._quote_path_segment(identifier)}", params=params) def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): """ @@ -358,7 +361,7 @@ def delete_template_credentials(self, identifier: str, data: Optional[dict] = No """ identifier = require_path_id(identifier, "identifier") - return self.request.delete(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + return self.request.delete(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) def update_template_credentials(self, identifier: str, data: Optional[dict] = None): """ @@ -366,7 +369,7 @@ def update_template_credentials(self, identifier: str, data: Optional[dict] = No """ identifier = require_path_id(identifier, "identifier") - return self.request.put(f"/template_credentials/{_quote_path_segment(identifier)}", data=data) + return self.request.put(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) # From 399aa1f47fc8a13bdbda32bf30f9d9afa134c736 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 10 Oct 2026 22:32:34 +0200 Subject: [PATCH 55/64] Record API contract coverage and 2.0 scope choices --- docs/api-coverage.md | 183 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 docs/api-coverage.md diff --git a/docs/api-coverage.md b/docs/api-coverage.md new file mode 100644 index 0000000..9cb70ac --- /dev/null +++ b/docs/api-coverage.md @@ -0,0 +1,183 @@ +# Python 2.0 API coverage checkpoint + +Measured on 2026-10-10, after merging #56 (`2397ea5`) into #57 (`79bfb19`). +This is a source audit and scope proposal, not a claim that the endpoints have +passed live contract-conformance tests. No new endpoint implementation is included +in this checkpoint. + +## Contract and counting rule + +- API2 revision: [`27622f3ecd09ffef6fc86a43dcfe14b95deaaad6`](https://github.com/transloadit/api2/commit/27622f3ecd09ffef6fc86a43dcfe14b95deaaad6). +- Source: [`api2/generated/contracts/v1/contract.json`](https://github.com/transloadit/api2/blob/27622f3ecd09ffef6fc86a43dcfe14b95deaaad6/api2/generated/contracts/v1/contract.json). +- SHA-256 of the committed contract bytes: `59c41853f194b01b6560f57a696afba89d774281d32f80d9ed03de724895a2a8`. +- Use `apiReference.operations` for the documented SDK surface: **44 operations**, + comprising **38 API2 operations and 6 raw TUS operations**. +- `contract.operations` contains **102 dispatch operations**. These also describe + edge routing, guards, method tunnels, aliases, fallbacks and separate products; + they are not 102 distinct SDK methods. +- Another **16 ordinary API routes** explicitly have + `apiReference.reason = separate-product-surface`. They are listed below rather + than silently counted as documented API-reference endpoints. +- At this revision `openapi.json` is a served projection, not a checked-in file at + `api2/generated/contracts/v1/openapi.json`. The canonical contract is the source + of this inventory. The old API2 SDK generator/example test commands mentioned + in #57 are absent from current API2 main. + +The sync and async clients have matching endpoint reachability: **22 of 38 API2 +operation IDs** have a callable path. Of these, 21 have the canonical HTTP method +and path; token issuance supports only one grant. The 22nd is replace-Assembly, +reachable via its accepted POST alias. **16 API2 operations have no wrapper**: +6 auth-key operations, 7 DAM operations, 2 statistics operations and the status +stream. TUS create/offset/PATCH are exercised through upload/resume workflows; +OPTIONS, download and delete are missing. None of the six has a standalone +low-level TUS endpoint method. + +Reachability does not certify every request field, auth alternative or response +mode. In particular, bearer-authenticated API requests and the token endpoint's +other grants are not implemented by the general request transports. + +## Sync and async coverage + +Each method below exists in both `Transloadit` and `AsyncTransloadit`; async calls +are awaited. The request/response helpers in `assembly.py`, `async_assembly.py`, +`template.py` and `async_template.py` remain separate high-level APIs. + +| Contract operation | Canonical request | Current sync and async coverage | +| --- | --- | --- | +| `api2.assembly-stats` | `GET /assembly_stats` | Missing | +| `api2.bulk-delete-dam-assets` | `POST /dam/assets/bulk/delete` | Missing | +| `api2.bulk-move-dam-assets` | `POST /dam/assets/bulk/move` | Missing | +| `api2.cancel-assembly` | `DELETE /assemblies/{assemblyId}` | `cancel_assembly` | +| `api2.create-assembly` | `POST /assemblies` | `create_assembly` | +| `api2.create-auth-key` | `POST /auth_keys` | Missing | +| `api2.create-template` | `POST /templates` | `create_template` | +| `api2.create-template-credential` | `POST /template_credentials` | `create_template_credentials` | +| `api2.delete-auth-key` | `DELETE /auth_keys/{authKeyId}` | Missing | +| `api2.delete-dam-asset` | `DELETE /dam/assets/{assetId}` | Missing | +| `api2.delete-template` | `DELETE /templates/{templateIdOrName}` | `delete_template` | +| `api2.delete-template-credential` | `DELETE /template_credentials/{templateCredentialId}` | `delete_template_credentials` | +| `api2.get-assembly` | `GET /assemblies/{assemblyId}` | `get_assembly` | +| `api2.get-bill` | `GET /bill/{billYearMonth}` | `get_bill` | +| `api2.get-dam-asset` | `GET /dam/assets/{assetId}` | Missing | +| `api2.get-template` | `GET /templates/{templateIdOrName}` | `get_template` | +| `api2.get-template-credential` | `GET /template_credentials/{templateCredentialId}` | `get_template_credentials` | +| `api2.issue-bearer-token` | `POST /token` | `issue_bearer_token` — client-credentials grant only | +| `api2.list-assemblies` | `GET /assemblies` | `list_assemblies` | +| `api2.list-assembly-notifications` | `GET /assembly_notifications/{assemblyId}` | `list_assembly_notifications` | +| `api2.list-auth-key-scopes` | `GET /auth_keys/scopes` | Missing | +| `api2.list-auth-keys` | `GET /auth_keys` | Missing | +| `api2.list-dam-assets` | `GET /dam/assets` | Missing | +| `api2.list-priority-job-slots` | `GET /queues/job_slots` | `list_priority_job_slots` | +| `api2.list-template-credential-types` | `GET /template_credentials/types` | `list_template_credential_types` | +| `api2.list-template-credentials` | `GET /template_credentials` | `list_template_credentials` | +| `api2.list-templates` | `GET /templates` | `list_templates` | +| `api2.move-dam-asset` | `PATCH /dam/assets/{assetId}` | Missing | +| `api2.move-dam-entry` | `POST /dam/entries/move` | Missing | +| `api2.priority-job-slot-stats` | `GET /priority_job_slot_stats` | Missing | +| `api2.replace-assembly` | `PUT /assemblies/{assemblyId}` | `create_assembly_with_id` — accepted POST alias; no canonical PUT wrapper | +| `api2.replay-assembly` | `POST /assemblies/{assemblyId}/replay` | `replay_assembly` | +| `api2.replay-assembly-notification` | `POST /assembly_notifications/{assemblyId}/replay` | `replay_assembly_notification` | +| `api2.show-auth-key-secret` | `POST /auth_keys/show_secret/{authKeyId}` | Missing | +| `api2.stream-assembly-status` | `GET /{statusStream}` | Missing | +| `api2.update-auth-key` | `PUT /auth_keys/{authKeyId}` | Missing | +| `api2.update-template` | `PUT /templates/{templateIdOrName}` | `update_template` | +| `api2.update-template-credential` | `PUT /template_credentials/{templateCredentialId}` | `update_template_credentials` | +| `tusd.create-upload` | `POST /resumable/files` | Indirect: `upload_tus_assembly` / resumable Assembly upload | +| `tusd.delete-upload` | `DELETE /resumable/files/{uploadId}` | Missing | +| `tusd.download-upload` | `GET /resumable/files/{uploadId}` | Missing | +| `tusd.get-upload-offset` | `HEAD /resumable/files/{uploadId}` | Indirect: `resume_tus_upload` / tuspy resume | +| `tusd.options` | `OPTIONS /resumable/files` | Missing | +| `tusd.patch-upload` | `PATCH /resumable/files/{uploadId}` | Indirect: upload/resume helpers / tuspy | + +## Compatibility and transport work + +- Add a canonical multipart PUT operation for replacing an Assembly; retain the + accepted POST helper as a compatibility alias. Both request helpers currently + accept files only on POST, so this is more than renaming the method. +- Add signed PATCH support for DAM. Preserve the producer's alpha stage on the + five staged DAM operations; do not describe them as stable. +- `issue_bearer_token` always selects `client_credentials`, forwards only `aud` + and `scope`, and requires an Auth Secret. The current contract also supports + authorization-code and refresh-token grants with different authentication. + Derive grant handling from `auth.byFormField`, not a second SDK grant inventory. +- The generic transports currently sign same-service requests and buffer their + bodies. SSE needs a separate streaming interface with incremental parsing, + bounded lifecycle/cancellation and response cleanup for both client types. +- Raw TUS requires response headers, binary bodies, capability destinations and + upload-resource lifecycle handling. Existing helpers cover normal upload and + resume, but do not constitute six complete raw endpoint wrappers. +- `get_builtin_template` and `get_bill_for_invoice` are variants of existing + published operations, not additional operation IDs. +- `get_template_full`, `get_builtin_template_full` and + `validate_template_credential_oauth_on_create` target routes now explicitly + marked internal in API2's dispatch registry. Do not regenerate or advertise + them as public endpoints. Their disposition must be documented when replacing + the obsolete generated blocks. + +## Separate product surface + +These 16 routes are present in the public dispatch contract, but API2 deliberately +excludes them from the main API-reference surface. Neither client has dedicated +methods for them. + +- `api2.storage-grants-create` +- `api2.storage-public-prefixes-list` +- `api2.storage-public-prefixes-declare` +- `api2.storage-public-prefixes-revoke` +- `api2.cli-device-authorizations-create` +- `api2.cli-device-authorizations-approve` +- `api2.cli-device-authorizations-deny` +- `api2.cli-device-authorizations-token` +- `api2.cli-device-authorizations-find` +- `api2.oauth-client-register` +- `api2.oauth-authorize-context` +- `api2.oauth-authorization-codes-create` +- `api2.oauth-revoke` +- `api2.oauth-connections-list` +- `api2.oauth-connection-revoke` +- `api2.revoke-own-auth-key` + +This list does not include delegated Companion/MCP, S3-compatible storage, +Socket.IO, public-platform discovery/fallbacks, operational recovery or dispatch +guards. Those are not ordinary low-level Transloadit endpoint methods. + +## Proposed release boundary — requires a decision + +**Option A: all documented operations in 2.0 (recommended).** Finish async plus +all **44 documented operations** in both clients, including SSE and all six raw +TUS operations. Keep handwritten Assembly, Template and upload/tuspy helpers. +Generate the low-level surface locally from a pinned API2 contract snapshot with +recorded producer revision/hash, deterministic bytes and an offline `--check` +in CI. Test the new authentication, multipart, PATCH, streaming and capability +boundaries. **2.1** adds the 16 separate-product routes after their storage, +device-authorization and OAuth flows have been designed and tested. Delegated +S3/MCP/Companion/Socket.IO protocols remain with their dedicated clients. + +**Option B: smaller 2.0, protocols in 2.1.** Ship async plus all **37 documented +non-streaming API2 operations**, retaining existing resumable upload/resume +helpers. Use the same pinned generation/check and update token grant handling. +**2.1** adds SSE, the standalone raw TUS surface (including currently missing +OPTIONS/download/delete), and the 16 separate-product routes. This is an explicit +reduction of the original full-surface requirement, so the release notes must +state the boundary. + +**Option C: include the additional product APIs in 2.0.** Implement the 44 +documented operations plus the 16 separate-product API routes before release. +This requires designing and testing OAuth connection, device-authorization and +storage-management flows too. It is a materially larger project than completing +the existing async draft. + +No option has been selected. The scope checkpoint occurs before implementing new +endpoint families. Council rounds, full final checks, live devdock scenarios, +CI validation and marking #57 ready with `tim-kos` follow the scope decision. + +## Checkpoint validation + +- Merged the current #56 branch, which already contains current SDK main, into + `asyncio-v2`; retained #56 as the PR base. +- Resolved the changelog conflict with the 2.0 `Unreleased` heading and current + migration requirements. README and Sphinx upgrade notes now include async in + 2.0 rather than contradicting the async examples. +- Python 3.12 Docker unit/example checks: **112 passed, 12 opt-in live skips**; + coverage **80.38%** (required floor: 65%). +- `git diff --check` passes. No publication, tagging or merge into main occurred. From d6361c9638e9fecd1daf0eaffac6fc057d648018 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 10 Oct 2026 23:04:22 +0200 Subject: [PATCH 56/64] Generate full sync and async API surface for Python 2.0 --- .gitattributes | 6 +- .github/workflows/ci.yml | 5 +- CHANGELOG.md | 4 +- README.md | 69 +++- contracts/api2-contract.json.gz | 3 + contracts/api2-contract.lock.json | 6 + docs/api-coverage.md | 294 ++++++-------- docs/source/index.rst | 58 ++- pyproject.toml | 5 + scripts/generate_endpoints.py | 219 ++++++++++ tests/test_async_client.py | 22 - tests/test_client.py | 2 - tests/test_contract_endpoints.py | 422 ++++++++++++++++++++ tests/test_e2e_endpoints.py | 85 ++++ tox.ini | 4 +- transloadit/_contract.py | 285 +++++++++++++ transloadit/async_client.py | 641 +++++++++++++++++------------- transloadit/async_request.py | 98 ++++- transloadit/client.py | 628 +++++++++++++++++------------ transloadit/endpoint_transport.py | 169 ++++++++ transloadit/request.py | 85 +++- transloadit/stream.py | 88 ++++ 22 files changed, 2403 insertions(+), 795 deletions(-) create mode 100644 contracts/api2-contract.json.gz create mode 100644 contracts/api2-contract.lock.json create mode 100644 scripts/generate_endpoints.py create mode 100644 tests/test_contract_endpoints.py create mode 100644 tests/test_e2e_endpoints.py create mode 100644 transloadit/_contract.py create mode 100644 transloadit/endpoint_transport.py create mode 100644 transloadit/stream.py diff --git a/.gitattributes b/.gitattributes index 49378f1..758ba4b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -41,4 +41,8 @@ *.webp filter=lfs diff=lfs merge=lfs -text *.woff2 filter=lfs diff=lfs merge=lfs -text *.xlsx filter=lfs diff=lfs merge=lfs -text -*.zip filter=lfs diff=lfs merge=lfs -text \ No newline at end of file +*.zip filter=lfs diff=lfs merge=lfs -text +/transloadit/client.py text eol=lf +/transloadit/async_client.py text eol=lf +/transloadit/_contract.py text eol=lf +/docs/api-coverage.md text eol=lf diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 53648b6..3bc5df8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -40,6 +40,9 @@ jobs: - name: Install Dependencies run: poetry install + - name: Check generated API endpoints + run: python scripts/generate_endpoints.py --check + - name: Test with coverage if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.14' run: | @@ -131,4 +134,4 @@ jobs: env: TEST_NODE_PARITY: 0 run: | - poetry run pytest tests/test_e2e_upload.py tests/test_examples.py -q --maxfail=1 --no-cov + poetry run pytest tests/test_e2e_upload.py tests/test_e2e_endpoints.py tests/test_examples.py -q --maxfail=1 --no-cov diff --git a/CHANGELOG.md b/CHANGELOG.md index 6dbc5fd..8f67d3e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,9 @@ * **Breaking Change**: Python 3.9, 3.10, and 3.11 are no longer supported. Installing 2.0 requires Python 3.12 or newer; upgrade the interpreter before upgrading the SDK. Applications that must stay on those older interpreters can pin `pytransloadit<2` (the latest 1.x release is 1.0.4). * **Breaking Change**: Runtime dependencies now require `requests>=2.33,<3` and `urllib3>=2.7,<3`. Remove or update older pins in application requirements/constraints and regenerate the application lockfile; incompatible pins will prevent installation. * The synchronous client API, imports, Assembly creation/polling, uploads, and Smart CDN signing remain compatible with 1.0.4 on supported interpreters. -* Expanded low-level API endpoint coverage for Assemblies, Assembly Notifications, Templates, Template Credentials, Priority Job Slots, and Billing, with sync and async methods generated from the API2 endpoint contract. +* Added all 44 documented API operations to both sync and async clients: Assemblies, Assembly Notifications, Templates, Template Credentials, auth keys and token grants, DAM, statistics, Priority Job Slots, Billing, SSE and raw TUS. DAM operations marked alpha retain that status. The 16 separate-product storage/device/OAuth routes are tracked for 2.1 in #60. +* Pinned the canonical API2 contract with producer revision and byte hash. Low-level methods and the coverage table regenerate deterministically; CI checks the committed bytes without API2 access. High-level Assembly, Template and upload helpers remain handwritten. +* Added signed PATCH, multipart PUT Assembly replacement, optional bearer-token authentication and authorization-code/refresh-token issuance. SSE supports incremental events and context-managed cancellation/cleanup. Raw TUS preserves binary downloads and response headers, validates returned destinations and does not forward account credentials or follow redirects. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. diff --git a/README.md b/README.md index 30b9cad..49212a0 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ python -m pip install --upgrade 'pytransloadit>=2,<3' ``` The synchronous client API and imports remain compatible with 1.0.4 on supported -interpreters. Python 2.0 adds the separate `AsyncTransloadit` client for asyncio +interpreters. SDK 2.0 adds the separate `AsyncTransloadit` client for asyncio applications. The dependency refresh shipped in 1.0.4 does not require upgrading to 2.0. @@ -58,23 +58,74 @@ print(assembly_response.data['assembly_id']) ## Async usage ```python +import asyncio +import os from transloadit.async_client import AsyncTransloadit -async with AsyncTransloadit("TRANSLOADIT_KEY", "TRANSLOADIT_SECRET") as tl: - response = await tl.get_assembly(assembly_id="abc") - print(response.data["ok"]) +async def main(): + async with AsyncTransloadit(os.environ["TRANSLOADIT_KEY"], os.environ["TRANSLOADIT_SECRET"]) as tl: + assembly = tl.new_assembly() + assembly.add_step("resize", "/image/resize", {"width": 70, "height": 70}) + with open("PATH/TO/FILE.jpg", "rb") as upload: + assembly.add_file(upload) + response = await assembly.create(wait=True, resumable=False) + print(response.data["ok"]) - assembly = tl.new_assembly() - assembly.add_step("resize", "/image/resize", {"width": 70, "height": 70}) - with open("PATH/TO/FILE.jpg", "rb") as upload: - assembly.add_file(upload) - response = await assembly.create(wait=True, resumable=False) +asyncio.run(main()) ``` The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded with `asyncio.to_thread()` so the event loop stays responsive. If you do not use `async with`, call `await tl.aclose()` when you are done with the session. +## API endpoint coverage + +Both clients expose all **44 documented API operations**: Assemblies and SSE, +Templates, Template Credentials, auth keys and token issuance, DAM, statistics, +Billing, job slots, Assembly Notifications, and the six raw TUS operations. +See the [complete coverage table and generation instructions](docs/api-coverage.md). +The five DAM operations marked alpha retain that status. The 16 separate-product +routes deferred to 2.1 are tracked in [#60](https://github.com/transloadit/python-sdk/issues/60). + +Ordinary GET methods take `params`, and other methods take `data`, as dictionaries +of the API's normalized request fields. Responses expose `.data`, `.status_code` +and `.headers`. For example, `await tl.list_auth_keys()` retrieves auth keys. +Check the endpoint reference for field names and required scopes. Signed requests +remain the default. To use a bearer token, pass +`bearer_token=token` to either client (the Auth Secret can be `None`). +`issue_bearer_token(data)` supports the contract's client-credentials, +authorization-code and refresh-token grants; omitted `grant_type` keeps the +client-credentials default. Tokens are not refreshed automatically. + +SSE uses the returned Assembly `update_stream_url` and a context manager: + +```python +# Inside an async function, after creating an Assembly: +async with tl.stream_assembly_status(created.data["update_stream_url"]) as events: + async for event in events: + print(event.event, event.data) +``` + +The sync equivalent uses `with` and `for`. Each event has `event`, parsed `data`, +`id`, `retry` and `terminal` attributes. Unknown events are delivered unchanged. +The stream stops on a terminal event; exiting the context, including cancellation, +closes the connection. A terminal event or disconnect does **not** establish +processing success: fetch `assembly_ssl_url` and inspect `ok`/`error`. +HTTP errors raise `transloadit.stream.StreamError` with `status_code`; streams +do not reconnect or replay automatically. Read inactivity defaults to 120 seconds, +and events are capped at 1 MiB; use `read_timeout` and `max_event_size` to adjust. + +For low-level resumable control, `tus_options(assembly)` and +`create_upload(assembly, headers=..., body=...)` take the Assembly response, pairing +its `tus_url` with `assembly_ssl_url`. Successful creation exposes a validated +`.upload_url`, suitable for persisting and passing to `get_upload_offset`, +`patch_upload`, `download_upload` or `delete_upload`. Supply TUS fields such as +`Upload-Length` and `Upload-Offset` through `headers`, and supply base64-encoded +`filename` / `fieldname` entries in `Upload-Metadata` when creating uploads; the +client adds protocol defaults and the Assembly metadata. Downloads return bytes, including JSON-looking +files. These raw methods return HTTP errors as `Response` objects; inspect status +codes. The high-level Assembly/tuspy helpers still handle normal uploads and polling. + ## Examples For copy/paste runnable examples, take a look at diff --git a/contracts/api2-contract.json.gz b/contracts/api2-contract.json.gz new file mode 100644 index 0000000..3ed6a4e --- /dev/null +++ b/contracts/api2-contract.json.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d79eb66da3d54a3e97c9a20758ee78846fbce07d7df0cd9744387f8f55f9295 +size 1012247 diff --git a/contracts/api2-contract.lock.json b/contracts/api2-contract.lock.json new file mode 100644 index 0000000..0e8a188 --- /dev/null +++ b/contracts/api2-contract.lock.json @@ -0,0 +1,6 @@ +{ + "repository": "https://github.com/transloadit/api2", + "revision": "27622f3ecd09ffef6fc86a43dcfe14b95deaaad6", + "path": "api2/generated/contracts/v1/contract.json", + "sha256": "59c41853f194b01b6560f57a696afba89d774281d32f80d9ed03de724895a2a8" +} diff --git a/docs/api-coverage.md b/docs/api-coverage.md index 9cb70ac..f78b110 100644 --- a/docs/api-coverage.md +++ b/docs/api-coverage.md @@ -1,183 +1,111 @@ -# Python 2.0 API coverage checkpoint - -Measured on 2026-10-10, after merging #56 (`2397ea5`) into #57 (`79bfb19`). -This is a source audit and scope proposal, not a claim that the endpoints have -passed live contract-conformance tests. No new endpoint implementation is included -in this checkpoint. - -## Contract and counting rule - -- API2 revision: [`27622f3ecd09ffef6fc86a43dcfe14b95deaaad6`](https://github.com/transloadit/api2/commit/27622f3ecd09ffef6fc86a43dcfe14b95deaaad6). -- Source: [`api2/generated/contracts/v1/contract.json`](https://github.com/transloadit/api2/blob/27622f3ecd09ffef6fc86a43dcfe14b95deaaad6/api2/generated/contracts/v1/contract.json). -- SHA-256 of the committed contract bytes: `59c41853f194b01b6560f57a696afba89d774281d32f80d9ed03de724895a2a8`. -- Use `apiReference.operations` for the documented SDK surface: **44 operations**, - comprising **38 API2 operations and 6 raw TUS operations**. -- `contract.operations` contains **102 dispatch operations**. These also describe - edge routing, guards, method tunnels, aliases, fallbacks and separate products; - they are not 102 distinct SDK methods. -- Another **16 ordinary API routes** explicitly have - `apiReference.reason = separate-product-surface`. They are listed below rather - than silently counted as documented API-reference endpoints. -- At this revision `openapi.json` is a served projection, not a checked-in file at - `api2/generated/contracts/v1/openapi.json`. The canonical contract is the source - of this inventory. The old API2 SDK generator/example test commands mentioned - in #57 are absent from current API2 main. - -The sync and async clients have matching endpoint reachability: **22 of 38 API2 -operation IDs** have a callable path. Of these, 21 have the canonical HTTP method -and path; token issuance supports only one grant. The 22nd is replace-Assembly, -reachable via its accepted POST alias. **16 API2 operations have no wrapper**: -6 auth-key operations, 7 DAM operations, 2 statistics operations and the status -stream. TUS create/offset/PATCH are exercised through upload/resume workflows; -OPTIONS, download and delete are missing. None of the six has a standalone -low-level TUS endpoint method. - -Reachability does not certify every request field, auth alternative or response -mode. In particular, bearer-authenticated API requests and the token endpoint's -other grants are not implemented by the general request transports. - -## Sync and async coverage - -Each method below exists in both `Transloadit` and `AsyncTransloadit`; async calls -are awaited. The request/response helpers in `assembly.py`, `async_assembly.py`, -`template.py` and `async_template.py` remain separate high-level APIs. - -| Contract operation | Canonical request | Current sync and async coverage | -| --- | --- | --- | -| `api2.assembly-stats` | `GET /assembly_stats` | Missing | -| `api2.bulk-delete-dam-assets` | `POST /dam/assets/bulk/delete` | Missing | -| `api2.bulk-move-dam-assets` | `POST /dam/assets/bulk/move` | Missing | -| `api2.cancel-assembly` | `DELETE /assemblies/{assemblyId}` | `cancel_assembly` | -| `api2.create-assembly` | `POST /assemblies` | `create_assembly` | -| `api2.create-auth-key` | `POST /auth_keys` | Missing | -| `api2.create-template` | `POST /templates` | `create_template` | -| `api2.create-template-credential` | `POST /template_credentials` | `create_template_credentials` | -| `api2.delete-auth-key` | `DELETE /auth_keys/{authKeyId}` | Missing | -| `api2.delete-dam-asset` | `DELETE /dam/assets/{assetId}` | Missing | -| `api2.delete-template` | `DELETE /templates/{templateIdOrName}` | `delete_template` | -| `api2.delete-template-credential` | `DELETE /template_credentials/{templateCredentialId}` | `delete_template_credentials` | -| `api2.get-assembly` | `GET /assemblies/{assemblyId}` | `get_assembly` | -| `api2.get-bill` | `GET /bill/{billYearMonth}` | `get_bill` | -| `api2.get-dam-asset` | `GET /dam/assets/{assetId}` | Missing | -| `api2.get-template` | `GET /templates/{templateIdOrName}` | `get_template` | -| `api2.get-template-credential` | `GET /template_credentials/{templateCredentialId}` | `get_template_credentials` | -| `api2.issue-bearer-token` | `POST /token` | `issue_bearer_token` — client-credentials grant only | -| `api2.list-assemblies` | `GET /assemblies` | `list_assemblies` | -| `api2.list-assembly-notifications` | `GET /assembly_notifications/{assemblyId}` | `list_assembly_notifications` | -| `api2.list-auth-key-scopes` | `GET /auth_keys/scopes` | Missing | -| `api2.list-auth-keys` | `GET /auth_keys` | Missing | -| `api2.list-dam-assets` | `GET /dam/assets` | Missing | -| `api2.list-priority-job-slots` | `GET /queues/job_slots` | `list_priority_job_slots` | -| `api2.list-template-credential-types` | `GET /template_credentials/types` | `list_template_credential_types` | -| `api2.list-template-credentials` | `GET /template_credentials` | `list_template_credentials` | -| `api2.list-templates` | `GET /templates` | `list_templates` | -| `api2.move-dam-asset` | `PATCH /dam/assets/{assetId}` | Missing | -| `api2.move-dam-entry` | `POST /dam/entries/move` | Missing | -| `api2.priority-job-slot-stats` | `GET /priority_job_slot_stats` | Missing | -| `api2.replace-assembly` | `PUT /assemblies/{assemblyId}` | `create_assembly_with_id` — accepted POST alias; no canonical PUT wrapper | -| `api2.replay-assembly` | `POST /assemblies/{assemblyId}/replay` | `replay_assembly` | -| `api2.replay-assembly-notification` | `POST /assembly_notifications/{assemblyId}/replay` | `replay_assembly_notification` | -| `api2.show-auth-key-secret` | `POST /auth_keys/show_secret/{authKeyId}` | Missing | -| `api2.stream-assembly-status` | `GET /{statusStream}` | Missing | -| `api2.update-auth-key` | `PUT /auth_keys/{authKeyId}` | Missing | -| `api2.update-template` | `PUT /templates/{templateIdOrName}` | `update_template` | -| `api2.update-template-credential` | `PUT /template_credentials/{templateCredentialId}` | `update_template_credentials` | -| `tusd.create-upload` | `POST /resumable/files` | Indirect: `upload_tus_assembly` / resumable Assembly upload | -| `tusd.delete-upload` | `DELETE /resumable/files/{uploadId}` | Missing | -| `tusd.download-upload` | `GET /resumable/files/{uploadId}` | Missing | -| `tusd.get-upload-offset` | `HEAD /resumable/files/{uploadId}` | Indirect: `resume_tus_upload` / tuspy resume | -| `tusd.options` | `OPTIONS /resumable/files` | Missing | -| `tusd.patch-upload` | `PATCH /resumable/files/{uploadId}` | Indirect: upload/resume helpers / tuspy | - -## Compatibility and transport work - -- Add a canonical multipart PUT operation for replacing an Assembly; retain the - accepted POST helper as a compatibility alias. Both request helpers currently - accept files only on POST, so this is more than renaming the method. -- Add signed PATCH support for DAM. Preserve the producer's alpha stage on the - five staged DAM operations; do not describe them as stable. -- `issue_bearer_token` always selects `client_credentials`, forwards only `aud` - and `scope`, and requires an Auth Secret. The current contract also supports - authorization-code and refresh-token grants with different authentication. - Derive grant handling from `auth.byFormField`, not a second SDK grant inventory. -- The generic transports currently sign same-service requests and buffer their - bodies. SSE needs a separate streaming interface with incremental parsing, - bounded lifecycle/cancellation and response cleanup for both client types. -- Raw TUS requires response headers, binary bodies, capability destinations and - upload-resource lifecycle handling. Existing helpers cover normal upload and - resume, but do not constitute six complete raw endpoint wrappers. -- `get_builtin_template` and `get_bill_for_invoice` are variants of existing - published operations, not additional operation IDs. -- `get_template_full`, `get_builtin_template_full` and - `validate_template_credential_oauth_on_create` target routes now explicitly - marked internal in API2's dispatch registry. Do not regenerate or advertise - them as public endpoints. Their disposition must be documented when replacing - the obsolete generated blocks. - -## Separate product surface - -These 16 routes are present in the public dispatch contract, but API2 deliberately -excludes them from the main API-reference surface. Neither client has dedicated -methods for them. - -- `api2.storage-grants-create` -- `api2.storage-public-prefixes-list` -- `api2.storage-public-prefixes-declare` -- `api2.storage-public-prefixes-revoke` -- `api2.cli-device-authorizations-create` -- `api2.cli-device-authorizations-approve` -- `api2.cli-device-authorizations-deny` -- `api2.cli-device-authorizations-token` -- `api2.cli-device-authorizations-find` -- `api2.oauth-client-register` -- `api2.oauth-authorize-context` -- `api2.oauth-authorization-codes-create` -- `api2.oauth-revoke` -- `api2.oauth-connections-list` -- `api2.oauth-connection-revoke` -- `api2.revoke-own-auth-key` - -This list does not include delegated Companion/MCP, S3-compatible storage, -Socket.IO, public-platform discovery/fallbacks, operational recovery or dispatch -guards. Those are not ordinary low-level Transloadit endpoint methods. - -## Proposed release boundary — requires a decision - -**Option A: all documented operations in 2.0 (recommended).** Finish async plus -all **44 documented operations** in both clients, including SSE and all six raw -TUS operations. Keep handwritten Assembly, Template and upload/tuspy helpers. -Generate the low-level surface locally from a pinned API2 contract snapshot with -recorded producer revision/hash, deterministic bytes and an offline `--check` -in CI. Test the new authentication, multipart, PATCH, streaming and capability -boundaries. **2.1** adds the 16 separate-product routes after their storage, -device-authorization and OAuth flows have been designed and tested. Delegated -S3/MCP/Companion/Socket.IO protocols remain with their dedicated clients. - -**Option B: smaller 2.0, protocols in 2.1.** Ship async plus all **37 documented -non-streaming API2 operations**, retaining existing resumable upload/resume -helpers. Use the same pinned generation/check and update token grant handling. -**2.1** adds SSE, the standalone raw TUS surface (including currently missing -OPTIONS/download/delete), and the 16 separate-product routes. This is an explicit -reduction of the original full-surface requirement, so the release notes must -state the boundary. - -**Option C: include the additional product APIs in 2.0.** Implement the 44 -documented operations plus the 16 separate-product API routes before release. -This requires designing and testing OAuth connection, device-authorization and -storage-management flows too. It is a materially larger project than completing -the existing async draft. - -No option has been selected. The scope checkpoint occurs before implementing new -endpoint families. Council rounds, full final checks, live devdock scenarios, -CI validation and marking #57 ready with `tim-kos` follow the scope decision. - -## Checkpoint validation - -- Merged the current #56 branch, which already contains current SDK main, into - `asyncio-v2`; retained #56 as the PR base. -- Resolved the changelog conflict with the 2.0 `Unreleased` heading and current - migration requirements. README and Sphinx upgrade notes now include async in - 2.0 rather than contradicting the async examples. -- Python 3.12 Docker unit/example checks: **112 passed, 12 opt-in live skips**; - coverage **80.38%** (required floor: 65%). -- `git diff --check` passes. No publication, tagging or merge into main occurred. +# Python 2.0 API coverage + +Python 2.0 implements all **44 documented operations** in both `Transloadit` and +`AsyncTransloadit`: 38 API2 endpoints and six raw TUS operations. Async ordinary +methods are awaited; `stream_assembly_status` returns an async context manager. +Assembly, Template, polling and tuspy upload helpers remain maintained by hand. + +The initial async draft reached 22 of 38 API2 operations, including a POST alias +for Assembly replacement and partial token issuance. The new methods add auth-key +management, DAM, statistics, canonical multipart replacement, SSE and raw TUS. + +## Reproducible generation + +`contracts/api2-contract.lock.json` records the producer revision and SHA-256 of +the original contract bytes. `contracts/api2-contract.json.gz` contains those +unmodified bytes compressed with a fixed timestamp. The pin is API2 main +`27622f3ecd09ffef6fc86a43dcfe14b95deaaad6`, published from +`api2/generated/contracts/v1/contract.json`. The SDK build does not require API2 +credentials or a network request. + +```bash +python scripts/generate_endpoints.py +python scripts/generate_endpoints.py --check +# Update only from a reviewed, committed API2 revision: +python scripts/generate_endpoints.py --api2-root ../api2 --ref +``` + +The generator consumes `apiReference.operations` and the corresponding dispatch +and exchange records. It derives HTTP paths/methods, transport kinds, stages, +token-grant authentication, protocol header defaults and SSE terminal events. +Python compatibility names are the only SDK-specific method-name overrides. +CI checks both client blocks, transport metadata and this table byte for byte. +The 102 public dispatch entries include guards, aliases, routing and separate +products; they are not 102 SDK endpoint methods. OpenAPI is a served projection +of the canonical contract, not a checked-in `openapi.json` file in this pin. + +## Documented operations + +Methods accept normalized request fields as a `params` dictionary for GET or +`data` for other ordinary methods. Pass files/extra fields to Assembly creation +and replacement. Response payloads remain dictionaries rather than generated +model classes. The server validates request fields. A covered operation does not +mean that every response or server-side permission has a live test in this repo. + + +| Operation | HTTP request | Sync / async method | Stage | +| --- | --- | --- | --- | +| `api2.assembly-stats` | `GET /assembly_stats` | `assembly_stats` | | +| `api2.bulk-delete-dam-assets` | `POST /dam/assets/bulk/delete` | `bulk_delete_dam_assets` | alpha | +| `api2.bulk-move-dam-assets` | `POST /dam/assets/bulk/move` | `bulk_move_dam_assets` | alpha | +| `api2.cancel-assembly` | `DELETE /assemblies/{assemblyId}` | `cancel_assembly` | | +| `api2.create-assembly` | `POST /assemblies` | `create_assembly` | | +| `api2.create-auth-key` | `POST /auth_keys` | `create_auth_key` | | +| `api2.create-template` | `POST /templates` | `create_template` | | +| `api2.create-template-credential` | `POST /template_credentials` | `create_template_credentials` | | +| `api2.delete-auth-key` | `DELETE /auth_keys/{authKeyId}` | `delete_auth_key` | | +| `api2.delete-dam-asset` | `DELETE /dam/assets/{assetId}` | `delete_dam_asset` | alpha | +| `api2.delete-template` | `DELETE /templates/{templateIdOrName}` | `delete_template` | | +| `api2.delete-template-credential` | `DELETE /template_credentials/{templateCredentialId}` | `delete_template_credentials` | | +| `api2.get-assembly` | `GET /assemblies/{assemblyId}` | `get_assembly` | | +| `api2.get-bill` | `GET /bill/{billYearMonth}` | `get_bill` | | +| `api2.get-dam-asset` | `GET /dam/assets/{assetId}` | `get_dam_asset` | | +| `api2.get-template` | `GET /templates/{templateIdOrName}` | `get_template` | | +| `api2.get-template-credential` | `GET /template_credentials/{templateCredentialId}` | `get_template_credentials` | | +| `api2.issue-bearer-token` | `POST /token` | `issue_bearer_token` | | +| `api2.list-assemblies` | `GET /assemblies` | `list_assemblies` | | +| `api2.list-assembly-notifications` | `GET /assembly_notifications/{assemblyId}` | `list_assembly_notifications` | | +| `api2.list-auth-key-scopes` | `GET /auth_keys/scopes` | `list_auth_key_scopes` | | +| `api2.list-auth-keys` | `GET /auth_keys` | `list_auth_keys` | | +| `api2.list-dam-assets` | `GET /dam/assets` | `list_dam_assets` | | +| `api2.list-priority-job-slots` | `GET /queues/job_slots` | `list_priority_job_slots` | | +| `api2.list-template-credential-types` | `GET /template_credentials/types` | `list_template_credential_types` | | +| `api2.list-template-credentials` | `GET /template_credentials` | `list_template_credentials` | | +| `api2.list-templates` | `GET /templates` | `list_templates` | | +| `api2.move-dam-asset` | `PATCH /dam/assets/{assetId}` | `move_dam_asset` | alpha | +| `api2.move-dam-entry` | `POST /dam/entries/move` | `move_dam_entry` | alpha | +| `api2.priority-job-slot-stats` | `GET /priority_job_slot_stats` | `priority_job_slot_stats` | | +| `api2.replace-assembly` | `PUT /assemblies/{assemblyId}` | `replace_assembly` | | +| `api2.replay-assembly` | `POST /assemblies/{assemblyId}/replay` | `replay_assembly` | | +| `api2.replay-assembly-notification` | `POST /assembly_notifications/{assemblyId}/replay` | `replay_assembly_notification` | | +| `api2.show-auth-key-secret` | `POST /auth_keys/show_secret/{authKeyId}` | `show_auth_key_secret` | | +| `api2.stream-assembly-status` | `GET /{statusStream}` | `stream_assembly_status` | | +| `api2.update-auth-key` | `PUT /auth_keys/{authKeyId}` | `update_auth_key` | | +| `api2.update-template` | `PUT /templates/{templateIdOrName}` | `update_template` | | +| `api2.update-template-credential` | `PUT /template_credentials/{templateCredentialId}` | `update_template_credentials` | | +| `tusd.create-upload` | `POST /resumable/files` | `create_upload` | | +| `tusd.delete-upload` | `DELETE /resumable/files/{uploadId}` | `delete_upload` | | +| `tusd.download-upload` | `GET /resumable/files/{uploadId}` | `download_upload` | | +| `tusd.get-upload-offset` | `HEAD /resumable/files/{uploadId}` | `get_upload_offset` | | +| `tusd.options` | `OPTIONS /resumable/files` | `tus_options` | | +| `tusd.patch-upload` | `PATCH /resumable/files/{uploadId}` | `patch_upload` | | + + +## Compatibility and 2.1 boundary + +The five staged DAM operations retain their producer's alpha designation. +`create_assembly_with_id` remains the accepted POST replacement alias; +`replace_assembly` uses canonical PUT. Builtin Template and invoice helpers are +variants of existing public operations, not additional operation IDs. + +The inherited `get_template_full`, `get_builtin_template_full` and +`validate_template_credential_oauth_on_create` helpers remain for compatibility +with the draft. API2 now classifies these Console routes as internal: they are +excluded from public-contract generation and the table above. Use the documented +Template and Template Credential APIs for new integrations. + +The 16 storage-management, device-authorization, OAuth and self-revocation routes +marked `separate-product-surface` are deferred to +[Python 2.1 issue #60](https://github.com/transloadit/python-sdk/issues/60). +Delegated S3/MCP/Companion/Socket.IO protocols, dispatch guards and operational +recovery routes are outside this SDK endpoint surface. diff --git a/docs/source/index.rst b/docs/source/index.rst index 8166b7b..9233550 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -64,7 +64,7 @@ application pins or constraints and regenerate your application lockfile. python -m pip install --upgrade 'pytransloadit>=2,<3' The synchronous client API and imports remain compatible with 1.0.4 on supported -interpreters. Python 2.0 adds the separate ``AsyncTransloadit`` client for asyncio +interpreters. SDK 2.0 adds the separate ``AsyncTransloadit`` client for asyncio applications. The dependency refresh shipped in 1.0.4 does not require upgrading to 2.0. @@ -91,19 +91,59 @@ Async usage .. code:: python + import asyncio + import os from transloadit.async_client import AsyncTransloadit - async with AsyncTransloadit('TRANSLOADIT_KEY', 'TRANSLOADIT_SECRET') as tl: - response = await tl.get_assembly(assembly_id='abc') - print(response.data['ok']) + async def main(): + async with AsyncTransloadit(os.environ['TRANSLOADIT_KEY'], os.environ['TRANSLOADIT_SECRET']) as tl: + assembly = tl.new_assembly() + assembly.add_step('resize', '/image/resize', {'width': 70, 'height': 70}) + with open('PATH/TO/FILE.jpg', 'rb') as upload: + assembly.add_file(upload) + response = await assembly.create(wait=True, resumable=False) + print(response.data['ok']) - assembly = tl.new_assembly() - assembly.add_step('resize', '/image/resize', {'width': 70, 'height': 70}) - with open('PATH/TO/FILE.jpg', 'rb') as upload: - assembly.add_file(upload) - response = await assembly.create(wait=True, resumable=False) + asyncio.run(main()) If you do not use ``async with``, call ``await tl.aclose()`` when you are done with the session. +Resumable uploads through tuspy run in a worker thread; polling uses ``asyncio.sleep``. + +Endpoint coverage +----------------- + +Both clients implement all 44 documented operations: 38 API2 endpoints plus six +raw TUS operations. See the `coverage table`_ for methods, HTTP routes, alpha +stages and the pinned contract generation/check procedure. The 16 separate-product +storage/device/OAuth routes are tracked for 2.1 in `issue 60`_. + +GET methods accept normalized API fields in ``params``; other ordinary methods +accept ``data``. Creation and replacement of Assemblies also accept ``extra_data`` +and ``files``. Requests are signed by default; pass ``bearer_token`` to use an +existing token. ``issue_bearer_token`` also supports authorization-code and refresh +flows. Automatic refresh is not performed. + +``stream_assembly_status`` takes the returned ``update_stream_url`` and is used +with ``with`` / ``async with``. Iterate its events with ``for`` / ``async for``; +the context closes the connection on exit or cancellation. Unknown events remain +available to callers. Terminal events and disconnects do not imply success: +fetch the final Assembly Status and inspect ``ok`` / ``error``. HTTP failures +raise ``transloadit.stream.StreamError``. Read inactivity defaults to 120 seconds +and event size to 1 MiB, adjustable through ``read_timeout`` / ``max_event_size``. +There is no automatic reconnect or replay. + +For raw TUS, pass the Assembly response to ``tus_options`` / ``create_upload``. +Creation pairs ``tus_url`` and ``assembly_ssl_url`` and returns a validated +``upload_url`` alongside the response. Persist that URL for offset queries, +append, download and deletion. Pass protocol headers with ``headers`` and upload +bytes with ``body``. Include base64-encoded ``filename`` / ``fieldname`` entries in +``Upload-Metadata`` when creating uploads. The client adds the Assembly metadata. +Downloads always return bytes. Raw methods return HTTP errors +as Response objects; inspect their status. Existing high-level upload helpers +still manage normal uploads and polling. + +.. _coverage table: https://github.com/transloadit/python-sdk/blob/asyncio-v2/docs/api-coverage.md +.. _issue 60: https://github.com/transloadit/python-sdk/issues/60 Examples -------- diff --git a/pyproject.toml b/pyproject.toml index fc51196..79f87b3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -36,6 +36,11 @@ Repository = "https://github.com/transloadit/python-sdk" Documentation = "https://transloadit.readthedocs.io" [tool.poetry] +include = [ + { path = "contracts", format = "sdist" }, + { path = "scripts/generate_endpoints.py", format = "sdist" }, + { path = "docs/api-coverage.md", format = "sdist" }, +] packages = [ { include = "transloadit" }, ] diff --git a/scripts/generate_endpoints.py b/scripts/generate_endpoints.py new file mode 100644 index 0000000..55b5e98 --- /dev/null +++ b/scripts/generate_endpoints.py @@ -0,0 +1,219 @@ +#!/usr/bin/env python3 +"""Generate SDK methods from the pinned, unmodified API2 public contract. + +No network or API2 checkout is needed for generation/checking. To update the pin, +pass --api2-root and --ref (a reviewed, committed producer revision). +""" +import argparse +import gzip +import hashlib +import json +from pathlib import Path +import pprint +import re +import subprocess + + +ROOT = Path(__file__).resolve().parents[1] +PIN = ROOT / "contracts/api2-contract.json.gz" +LOCK = ROOT / "contracts/api2-contract.lock.json" +START = " # " +END = " # " +# Python compatibility names only. HTTP facts always come from the contract. +NAMES = { + "create-template-credential": "create_template_credentials", + "get-template-credential": "get_template_credentials", + "update-template-credential": "update_template_credentials", + "delete-template-credential": "delete_template_credentials", + "options": "tus_options", +} +PARAMETERS = { + "templateIdOrName": "template_id", + "templateCredentialId": "identifier", +} + + +def snake(name): + return re.sub(r"(?", 1) + _, end = tail.split("", 1) + outputs[coverage] = start + "\n" + "\n".join(rows) + "\n" + end + return outputs + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--check", action="store_true") + parser.add_argument("--api2-root", type=Path) + parser.add_argument("--ref") + args = parser.parse_args() + if args.api2_root or args.ref: + if args.check or not (args.api2_root and args.ref): + parser.error("Pin updates require --api2-root and --ref, without --check") + revision = subprocess.check_output(["git", "-C", str(args.api2_root), "rev-parse", args.ref + "^{commit}"], text=True).strip() + source_path = "api2/generated/contracts/v1/contract.json" + raw = subprocess.check_output(["git", "-C", str(args.api2_root), "show", f"{revision}:{source_path}"]) + PIN.write_bytes(gzip.compress(raw, mtime=0)) + LOCK.write_text(json.dumps({"repository": "https://github.com/transloadit/api2", "revision": revision, "path": source_path, + "sha256": hashlib.sha256(raw).hexdigest()}, indent=2) + "\n", encoding="utf-8", newline="\n") + lock = json.loads(LOCK.read_text(encoding="utf-8")) + raw = gzip.decompress(PIN.read_bytes()) + if hashlib.sha256(raw).hexdigest() != lock["sha256"]: + raise SystemExit("Pinned API2 contract hash mismatch") + contract = json.loads(raw) + if contract["formatVersion"] != 1 or contract["format"] != "transloadit-public-dispatch-contract": + raise SystemExit("Unsupported API2 contract format") + stale = [] + for path, text in generate(contract, lock).items(): + expected = text.encode("utf-8") + if args.check: + if not path.exists() or path.read_bytes() != expected: + stale.append(str(path.relative_to(ROOT))) + else: + path.write_bytes(expected) + if stale: + raise SystemExit("Generated endpoints are stale: " + ", ".join(stale)) + print(f"{'Checked' if args.check else 'Generated'} {len(contract['apiReference']['operations'])} operations for sync and async clients") + + +if __name__ == "__main__": + main() diff --git a/tests/test_async_client.py b/tests/test_async_client.py index a4e8576..fc1596f 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -286,26 +286,6 @@ async def asyncSetUp(self): async def asyncTearDown(self): await self.server.close() - async def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self): - session = _RecordingSession({ - "access_token": "abc", - "expires_in": 21600, - "scope": "assemblies:read", - "token_type": "Bearer", - }) - client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) - - response = await client.issue_bearer_token({"scope": "assemblies:read"}) - - self.assertEqual(response.data["access_token"], "abc") - url, kwargs = session.calls[0] - self.assertEqual(url, f"{self.server.base_url}/token") - self.assertEqual( - kwargs["data"], - {"grant_type": "client_credentials", "scope": "assemblies:read"}, - ) - self.assertEqual(kwargs["headers"]["Authorization"], "Basic a2V5OnNlY3JldA==") - self.assertFalse(kwargs["allow_redirects"]) async def test_issue_bearer_token_rejects_127_prefixed_domain(self): session = _RecordingSession({}) @@ -523,7 +503,6 @@ async def test_async_generated_endpoint_methods_call_request_helpers(self): {"type": "dropbox"} ) await client.create_template_credentials(credential_data) - await client.list_assembly_notifications("assembly/with?chars") await client.get_builtin_template("builtin/with?chars") await client.get_template_full("template/with?chars") await client.get_builtin_template_full("builtin/full?chars") @@ -562,7 +541,6 @@ async def test_async_generated_endpoint_methods_call_request_helpers(self): self.assertEqual( get_mock.await_args_list, [ - mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), mock.call("/templates/template%2Fwith%3Fchars/full", params=None), mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), diff --git a/tests/test_client.py b/tests/test_client.py index fd2eb23..71fc628 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -252,7 +252,6 @@ def test_generated_endpoint_methods_call_request_helpers(self): {"type": "dropbox"} ) self.transloadit.create_template_credentials(credential_data) - self.transloadit.list_assembly_notifications("assembly/with?chars") self.transloadit.get_builtin_template("builtin/with?chars") self.transloadit.get_template_full("template/with?chars") self.transloadit.get_builtin_template_full("builtin/full?chars") @@ -293,7 +292,6 @@ def test_generated_endpoint_methods_call_request_helpers(self): self.assertEqual( get_mock.call_args_list, [ - mock.call("/assembly_notifications/assembly%2Fwith%3Fchars"), mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), mock.call("/templates/template%2Fwith%3Fchars/full", params=None), mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py new file mode 100644 index 0000000..fcf2d3a --- /dev/null +++ b/tests/test_contract_endpoints.py @@ -0,0 +1,422 @@ +import json +import asyncio +import base64 +import hashlib +import hmac +import io +import subprocess +import sys +from contextlib import asynccontextmanager +from pathlib import Path +from urllib.parse import parse_qs + +from aiohttp import web +import pytest +from requests.structures import CaseInsensitiveDict + +from transloadit.client import Transloadit +from transloadit.async_client import AsyncTransloadit +from transloadit.stream import EventParser, StreamError +from transloadit.endpoint_transport import tus_request, validate_upload_location +from transloadit.response import Response + + +def test_create_auth_key_sends_signed_request(requests_mock): + endpoint = requests_mock.post( + "https://api2.transloadit.com/auth_keys", json={"ok": "AUTH_KEY_CREATED"} + ) + client = Transloadit("key", "secret") + response = client.create_auth_key({"description": "worker", "scope": "assemblies:read"}) + payload = parse_qs(endpoint.last_request.text) + params = json.loads(payload["params"][0]) + assert params["description"] == "worker" + assert params["scope"] == "assemblies:read" + assert params["auth"]["key"] == "key" + assert payload["signature"][0].startswith("sha384:") + assert response.data == {"ok": "AUTH_KEY_CREATED"} + + +def test_move_dam_asset_uses_patch(requests_mock): + endpoint = requests_mock.patch( + "https://api2.transloadit.com/dam/assets/asset-123", json={"ok": "ASSET_MOVED"} + ) + response = Transloadit("key", "secret").move_dam_asset("asset-123", {"filename": "new.jpg"}) + assert endpoint.call_count == 1 + assert response.data["ok"] == "ASSET_MOVED" + + +ASSEMBLY_ID = "a" * 32 + + +class WireServer: + def __init__(self): + self.requests = [] + self.upload = b"" + self.disconnected = asyncio.Event() + self.started = asyncio.Event() + self.stream_mode = "normal" + + async def handle(self, request): + data = b"" + fields = {} + if request.content_type == "multipart/form-data": + for key, value in (await request.post()).items(): + fields[key] = value.file.read() if isinstance(value, web.FileField) else value + else: + data = await request.read() + if request.content_type == "application/x-www-form-urlencoded": + fields = {key: values[0] for key, values in parse_qs(data.decode()).items()} + record = {"method": request.method, "path": request.path, "body": data, + "fields": fields, "query": dict(request.query), "headers": CaseInsensitiveDict(request.headers)} + self.requests.append(record) + if request.path == "/ws1": + if self.stream_mode == "redirect": + return web.Response(status=302, headers={"Location": self.url + "/redirect-target"}) + if self.stream_mode == "unavailable": + return web.Response(status=503) + response = web.StreamResponse(headers={"Content-Type": "text/event-stream"}) + await response.prepare(request) + try: + if self.stream_mode == "normal": + payload = ('\ufeff: heartbeat\r\nevent: assembly_execution_progress\r\n' + 'data: {"progress_combined": 50,\r\ndata: "label": "café"}\r\n\r\n' + 'event: future_event\ndata: {"value": true}\n\n' + 'data: assembly_finished\n\n' + 'data: must_not_be_delivered\n\n').encode() + for byte in payload: + await response.write(bytes([byte])) + else: + await response.write(b"data: ping\n\n") + self.started.set() + for _ in range(100): + await asyncio.sleep(.01) + await response.write(b": heartbeat\n\n") + except (ConnectionResetError, asyncio.CancelledError): + self.disconnected.set() + return response + if request.path == "/resumable/files": + if request.method == "OPTIONS": + return web.Response(status=204, headers={"Tus-Version": "1.0.0", "Tus-Extension": "creation,termination"}) + self.upload = data + return web.Response(status=201, headers={"Location": "/resumable/files/upload-1", "Upload-Offset": str(len(data))}) + if request.path == "/resumable/files/upload-1": + if request.method == "HEAD": + return web.Response(headers={"Upload-Offset": str(len(self.upload)), "Upload-Length": "6"}) + if request.method == "PATCH": + assert int(request.headers["Upload-Offset"]) == len(self.upload) + self.upload += data + return web.Response(status=204, headers={"Upload-Offset": str(len(self.upload))}) + if request.method == "DELETE": + self.upload = b"" + return web.Response(status=204) + if request.headers.get("Range") == "bytes=1-2": + return web.Response(status=206, body=self.upload[1:3], headers={"Content-Range": "bytes 1-2/6"}) + return web.Response(body=self.upload, content_type="application/octet-stream") + return web.json_response({"ok": "OK", "access_token": "token-value"}) + + +@asynccontextmanager +async def wire_client(mode, *, bearer_token=None): + server = WireServer() + app = web.Application() + app.router.add_route("*", "/{path:.*}", server.handle) + runner = web.AppRunner(app, shutdown_timeout=.1) + await runner.setup() + site = web.TCPSite(runner, "127.0.0.1", 0) + await site.start() + server.url = "http://127.0.0.1:" + str(site._server.sockets[0].getsockname()[1]) + cls = Transloadit if mode == "sync" else AsyncTransloadit + client = cls("key", "secret", service=server.url, bearer_token=bearer_token) + try: + yield client, server + finally: + if mode == "async": + await client.aclose() + await runner.cleanup() + + +async def call(client, method, *args, **kwargs): + operation = getattr(client, method) + if isinstance(client, AsyncTransloadit): + return await operation(*args, **kwargs) + return await asyncio.to_thread(operation, *args, **kwargs) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("name,verb,path,args", [ + ("create_auth_key", "POST", "/auth_keys", ()), + ("delete_auth_key", "DELETE", "/auth_keys/key-id", ("key-id",)), + ("update_auth_key", "PUT", "/auth_keys/key-id", ("key-id",)), + ("list_auth_keys", "GET", "/auth_keys", ()), + ("list_auth_key_scopes", "GET", "/auth_keys/scopes", ()), + ("show_auth_key_secret", "POST", "/auth_keys/show_secret/key-id", ("key-id",)), + ("get_dam_asset", "GET", "/dam/assets/asset-id", ("asset-id",)), + ("list_dam_assets", "GET", "/dam/assets", ()), + ("move_dam_asset", "PATCH", "/dam/assets/asset-id", ("asset-id",)), + ("move_dam_entry", "POST", "/dam/entries/move", ()), + ("delete_dam_asset", "DELETE", "/dam/assets/asset-id", ("asset-id",)), + ("bulk_move_dam_assets", "POST", "/dam/assets/bulk/move", ()), + ("bulk_delete_dam_assets", "POST", "/dam/assets/bulk/delete", ()), + ("assembly_stats", "GET", "/assembly_stats", ()), + ("priority_job_slot_stats", "GET", "/priority_job_slot_stats", ()), +]) +def test_new_endpoints_preserve_signed_wire_payload(mode, name, verb, path, args): + async def scenario(): + async with wire_client(mode) as (client, server): + payload = {"custom": {"nested": [False, 3]}, "auth": {"max_size": 1024}} + original = json.loads(json.dumps(payload)) + response = await call(client, name, *args, **{"params" if verb == "GET" else "data": payload}) + request = server.requests[-1] + assert (request["method"], request["path"]) == (verb, path) + fields = request["query"] if verb == "GET" else request["fields"] + params = json.loads(fields["params"]) + assert params["custom"] == payload["custom"] + assert params["auth"]["max_size"] == 1024 + assert params["auth"]["key"] == "key" + expected = hmac.new(b"secret", fields["params"].encode(), hashlib.sha384).hexdigest() + assert fields["signature"] == "sha384:" + expected + assert payload == original + assert response.data["ok"] == "OK" + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_replacement_sends_multipart_and_keeps_file_open(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + stream = io.BytesIO(b"file bytes") + await call(client, "replace_assembly", ASSEMBLY_ID, {"steps": {}}, {"field": True}, {"file": stream}) + request = server.requests[-1] + assert request["method"] == "PUT" + assert request["path"] == "/assemblies/" + ASSEMBLY_ID + assert request["fields"]["file"] == b"file bytes" + assert request["fields"]["field"] == "True" + assert json.loads(request["fields"]["params"])["steps"] == {} + assert not stream.closed + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_bearer_requests_and_public_notifications_have_distinct_auth(mode): + async def scenario(): + async with wire_client(mode, bearer_token="bearer-value") as (client, server): + await call(client, "list_auth_keys", {"fields": ["name"]}) + request = server.requests[-1] + assert request["headers"]["Authorization"] == "Bearer bearer-value" + assert json.loads(request["query"]["params"]) == {"fields": ["name"]} + assert "signature" not in request["query"] + await call(client, "list_assembly_notifications", ASSEMBLY_ID, {"page": 2}) + request = server.requests[-1] + assert "Authorization" not in request["headers"] + assert request["query"] == {"page": "2"} + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("data,authorization", [ + ({"scope": "assemblies:read"}, "Basic a2V5OnNlY3JldA=="), + ({"grant_type": "authorization_code", "code": "code", "code_verifier": "proof", "client_id": "id", "redirect_uri": "https://example.test/callback"}, None), + ({"grant_type": "refresh_token", "refresh_token": "refresh", "client_id": "id", "resource": "https://api2.transloadit.com"}, None), +]) +def test_token_grants_forward_fields_with_contract_auth(mode, data, authorization): + async def scenario(): + async with wire_client(mode) as (client, server): + if authorization is None: + client.auth_secret = None + response = await call(client, "issue_bearer_token", data) + request = server.requests[-1] + assert (request["method"], request["path"]) == ("POST", "/token") + assert request["headers"].get("Authorization") == authorization + assert request["fields"] == {"grant_type": "client_credentials", **data} + assert "signature" not in request["fields"] + assert response.data["access_token"] == "token-value" + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_all_six_raw_tus_operations(mode): + async def scenario(): + async with wire_client(mode, bearer_token="must-not-leak") as (client, server): + assembly = {"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": server.url + "/assemblies/" + ASSEMBLY_ID, + "tus_url": server.url + "/resumable/files"} + response = await call(client, "tus_options", assembly) + assert response.headers["tus-version"] == "1.0.0" + response = await call(client, "create_upload", assembly, headers={"Upload-Length": "6"}, body=b"{a") + assert response.status_code == 201 + assert response.headers["Location"] == "/resumable/files/upload-1" + upload_url = response.upload_url + request = server.requests[-1] + metadata = request["headers"]["Upload-Metadata"].split(" ", 1)[1] + assert base64.b64decode(metadata).decode() == assembly["assembly_ssl_url"] + response = await call(client, "get_upload_offset", upload_url) + assert response.headers["upload-offset"] == "2" + response = await call(client, "patch_upload", upload_url, headers={"Upload-Offset": "2"}, body=b"bc}\xff") + assert response.headers["Upload-Offset"] == "6" + response = await call(client, "download_upload", upload_url) + assert response.data == b"{abc}\xff" + response = await call(client, "download_upload", upload_url, headers={"Range": "bytes=1-2"}) + assert response.status_code == 206 and response.data == b"ab" + response = await call(client, "delete_upload", upload_url) + assert response.status_code == 204 and server.upload == b"" + for request in server.requests: + assert "Authorization" not in request["headers"] + assert "params" not in request["query"] + assert "signature" not in request["query"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_stream_decodes_split_unicode_multiline_and_terminal_events(mode): + async def scenario(): + async with wire_client(mode, bearer_token="must-not-leak") as (client, server): + url = server.url + "/ws1?assembly=" + ASSEMBLY_ID + if mode == "sync": + def consume(): + with client.stream_assembly_status(url) as events: + return list(events) + events = await asyncio.to_thread(consume) + else: + async with client.stream_assembly_status(url) as stream: + events = [event async for event in stream] + assert [e.event for e in events] == ["assembly_execution_progress", "future_event", "assembly_finished"] + assert events[0].data == {"progress_combined": 50, "label": "café"} + assert events[-1].terminal + assert server.requests[-1]["headers"]["Accept"] == "text/event-stream" + assert "Authorization" not in server.requests[-1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("behavior,status", [("redirect", 302), ("unavailable", 503)]) +def test_stream_errors_do_not_follow_redirects(mode, behavior, status): + async def scenario(): + async with wire_client(mode) as (client, server): + server.stream_mode = behavior + url = server.url + "/ws1?assembly=" + ASSEMBLY_ID + with pytest.raises(StreamError) as caught: + if mode == "sync": + def consume(): + with client.stream_assembly_status(url) as events: + list(events) + await asyncio.to_thread(consume) + else: + async with client.stream_assembly_status(url): + pass + assert caught.value.status_code == status + assert len(server.requests) == 1 + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_stream_early_exit_closes_connection(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + server.stream_mode = "held" + url = server.url + "/ws1?assembly=" + ASSEMBLY_ID + if mode == "sync": + def consume(): + with client.stream_assembly_status(url) as events: + assert next(events).event == "ping" + await asyncio.to_thread(consume) + else: + async def consume(): + async with client.stream_assembly_status(url) as events: + assert (await anext(events)).event == "ping" + await asyncio.sleep(100) + task = asyncio.create_task(consume()) + await asyncio.wait_for(server.started.wait(), 2) + await asyncio.sleep(.02) + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + await asyncio.wait_for(server.disconnected.wait(), 2) + asyncio.run(scenario()) + + +def test_event_parser_bounds_and_eof_behavior(): + parser = EventParser(max_event_size=30) + with pytest.raises(ValueError, match="max_event_size"): + list(parser.feed(b"data: " + b"a" * 31)) + parser = EventParser() + assert list(parser.feed(b"data: incomplete")) == [] + parser = EventParser() + events = list(parser.feed(b"id: 2\nretry: 123\nevent: assembly_error\ndata: {\"error\":\"failed\"}\n\n")) + assert events[0].id == "2" and events[0].retry == 123 + assert events[0].terminal and events[0].data["error"] == "failed" + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("url", [ + "https://evil.test/resumable/files/x", "https://api2.transloadit.com.evil.test/resumable/files/x", + "https://user:password@api2.transloadit.com/resumable/files/x", "http://api2.transloadit.com/resumable/files/x", + "https://api2.transloadit.com/resumable/files/../admin", "https://api2.transloadit.com/resumable/files/%2e%2e/admin", + "https://api2.transloadit.com/templates/x", "https://api2.transloadit.com/resumable/files/x#fragment", + "https://api2.transloadit.com/resumable/files/%252e%252e", + "https://api2.transloadit.com/resumable/files/a%2Fb", + "https://api2.transloadit.com/resumable/files/%ff", + "https://api2.transloadit.com/resumable/files/x?", +]) +def test_raw_upload_rejects_untrusted_capabilities(mode, url): + async def scenario(): + cls = Transloadit if mode == "sync" else AsyncTransloadit + client = cls("key", "secret") + try: + with pytest.raises(ValueError): + await call(client, "get_upload_offset", url) + finally: + if mode == "async": + await client.aclose() + asyncio.run(scenario()) + + +def test_generation_check(): + root = Path(__file__).resolve().parents[1] + subprocess.run([sys.executable, "scripts/generate_endpoints.py", "--check"], cwd=root, check=True) + + +def test_assembly_and_tus_can_use_distinct_trusted_regional_hosts(): + assembly = { + "assembly_id": ASSEMBLY_ID, + "assembly_ssl_url": "https://api2-cell.transloadit.com/assemblies/" + ASSEMBLY_ID, + "tus_url": "https://api2-region.transloadit.com/resumable/files/", + } + _, url, headers, _ = tus_request(Transloadit("key", "secret"), "tusd.create-upload", assembly, {"Upload-Length": "1"}, None) + assert url == assembly["tus_url"] + assert base64.b64decode(headers["upload-metadata"].split(" ", 1)[1]).decode() == assembly["assembly_ssl_url"] + + +@pytest.mark.parametrize("location", [ + "https://evil.test/resumable/files/id", "/resumable/files/../files/id", "/resumable/files/%2e%2e/id", "", +]) +def test_creation_rejects_untrusted_or_normalized_locations(location): + client = Transloadit("key", "secret") + response = Response(data="", status_code=201, headers=CaseInsensitiveDict({"Location": location})) + with pytest.raises(ValueError): + validate_upload_location(client, "https://api2-region.transloadit.com/resumable/files/", response) + + +def test_creation_accepts_location_from_another_trusted_uploader(): + client = Transloadit("key", "secret") + location = "https://api2-cell.transloadit.com/resumable/files/id" + response = Response(data="", status_code=201, headers=CaseInsensitiveDict({"Location": location})) + validate_upload_location(client, "https://api2-region.transloadit.com/resumable/files/", response) + assert response.upload_url == location + + +@pytest.mark.parametrize("field,value", [("Authorization", "Bearer secret"), ("Cookie", "session=secret"), ("Host", "evil.test")]) +def test_tus_rejects_ambient_credentials(field, value): + with pytest.raises(ValueError): + tus_request(Transloadit("key", "secret"), "tusd.get-upload-offset", + "https://api2-region.transloadit.com/resumable/files/id", {field: value}, None) + + +def test_tus_metadata_cannot_change_assembly_identity(): + assembly = {"assembly_id": ASSEMBLY_ID, + "assembly_ssl_url": "https://api2-cell.transloadit.com/assemblies/" + ASSEMBLY_ID, + "tus_url": "https://api2-region.transloadit.com/resumable/files/"} + client = Transloadit("key", "secret") + with pytest.raises(ValueError, match="override"): + tus_request(client, "tusd.create-upload", assembly, {"Upload-Metadata": "assembly_url YXR0YWNr"}, None) + assembly["assembly_id"] = "b" * 32 + with pytest.raises(ValueError, match="identity"): + tus_request(client, "tusd.create-upload", assembly, {}, None) diff --git a/tests/test_e2e_endpoints.py b/tests/test_e2e_endpoints.py new file mode 100644 index 0000000..1d27284 --- /dev/null +++ b/tests/test_e2e_endpoints.py @@ -0,0 +1,85 @@ +"""Opt-in test-account validation using the repository's existing E2E credentials.""" +import asyncio +import base64 +import os + +import pytest + +from transloadit.async_client import AsyncTransloadit +from transloadit.client import Transloadit +from .test_e2e_upload import _get_e2e_credentials, _is_enabled + + +pytestmark = [pytest.mark.e2e, pytest.mark.skipif(not _is_enabled(), reason="Set PYTHON_SDK_E2E=1")] + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_raw_tus_and_status_stream_lifecycle(mode): + async def scenario(): + key, secret = _get_e2e_credentials() + cls = Transloadit if mode == "sync" else AsyncTransloadit + client = cls(key, secret, service=os.getenv("TRANSLOADIT_SERVICE", "https://api2.transloadit.com")) + + async def call(name, *args, **kwargs): + if mode == "async": + return await getattr(client, name)(*args, **kwargs) + return await asyncio.to_thread(getattr(client, name), *args, **kwargs) + + assembly_url = None + stream_task = None + try: + scopes = await call("list_auth_key_scopes") + assert scopes.status_code == 200 + # Keep the Assembly waiting while its incomplete upload is tested/deleted. + assembly = await call("create_tus_assembly", 2) + assert assembly.status_code == 200 + assembly_url = assembly.data["assembly_ssl_url"] + options = await call("tus_options", assembly) + assert options.status_code in {200, 204} + assert "1.0.0" in options.headers["Tus-Version"] + metadata = "filename " + base64.b64encode(b"sdk-test.bin").decode() + ",fieldname " + base64.b64encode(b"file").decode() + created = await call("create_upload", assembly, headers={"Upload-Length": "16", "Upload-Metadata": metadata}) + assert created.status_code == 201, created.data + upload_url = created.upload_url + offset = await call("get_upload_offset", upload_url) + assert offset.status_code == 200 and offset.headers["Upload-Offset"] == "0" + appended = await call("patch_upload", upload_url, headers={"Upload-Offset": "0"}, body=b"sdk-test") + assert appended.status_code == 204 and appended.headers["Upload-Offset"] == "8" + downloaded = await call("download_upload", upload_url, headers={"Range": "bytes=1-3"}) + assert downloaded.status_code == 206 and downloaded.data == b"dk-" + deleted = await call("delete_upload", upload_url) + assert deleted.status_code == 204 + + opened = asyncio.Event() + loop = asyncio.get_running_loop() + stream_url = assembly.data["update_stream_url"] + + def consume_sync(): + with client.stream_assembly_status(stream_url, read_timeout=15) as events: + loop.call_soon_threadsafe(opened.set) + return list(events) + + async def consume_async(): + async with client.stream_assembly_status(stream_url, read_timeout=15) as events: + opened.set() + return [event async for event in events] + + stream_task = asyncio.create_task(consume_async() if mode == "async" else asyncio.to_thread(consume_sync)) + await asyncio.wait_for(opened.wait(), 20) + canceled = await call("cancel_assembly", assembly_url=assembly_url) + assert canceled.status_code == 200 + events = await asyncio.wait_for(asyncio.shield(stream_task), 20) + assert any(event.terminal for event in events) + status = await call("get_assembly", assembly_url=assembly_url) + assert status.data["ok"] == "ASSEMBLY_CANCELED" + finally: + try: + if assembly_url: + await call("cancel_assembly", assembly_url=assembly_url) + finally: + if stream_task: + # Sync stream reads have a finite timeout; await the owned worker. + await asyncio.gather(stream_task, return_exceptions=True) + if mode == "async": + await client.aclose() + asyncio.run(scenario()) diff --git a/tox.ini b/tox.ini index 59ea1db..2ae97b6 100644 --- a/tox.ini +++ b/tox.ini @@ -6,4 +6,6 @@ deps = pytest>=9.0.3,<10 pytest-cov>=7.1,<8 requests-mock>=1.12.1,<2 -commands = pytest tests +commands = + python scripts/generate_endpoints.py --check + pytest tests diff --git a/transloadit/_contract.py b/transloadit/_contract.py new file mode 100644 index 0000000..573cd3d --- /dev/null +++ b/transloadit/_contract.py @@ -0,0 +1,285 @@ +# Generated by scripts/generate_endpoints.py. Do not edit. +CONTRACT = {'capability': {'assemblyField': 'assembly_ssl_url', + 'collectionField': 'tus_url', + 'creationStatus': 201, + 'identityField': 'assembly_id', + 'locationHeader': 'location', + 'metadataHeader': 'upload-metadata', + 'metadataName': 'assembly_url', + 'publicHostPattern': '^api2-(?!xn--)[a-z0-9](?:[a-z0-9-]{0,56}[a-z0-9])?\\.transloadit\\.com$', + 'routes': [{'kind': 'create-assembly', 'parameters': [], 'path': '/assemblies'}, + {'kind': 'status-stream', + 'parameters': [{'name': 'statusStream', + 'pattern': '^ws[0-9]+$', + 'percentDecode': False}], + 'path': '/{statusStream}'}, + {'kind': 'assembly', + 'parameters': [{'name': 'assemblyId', + 'pattern': '^[a-z0-9]{32}$', + 'percentDecode': False}], + 'path': '/assemblies/{assemblyId}'}, + {'kind': 'assembly', + 'parameters': [{'name': 'assemblyId', + 'pattern': '^[a-z0-9]{32}$', + 'percentDecode': False}], + 'path': '/assemblies/{assemblyId}'}, + {'kind': 'create-assembly', + 'parameters': [{'name': 'assemblyId', + 'pattern': '^[a-z0-9]{32}$', + 'percentDecode': False}], + 'path': '/assemblies/{assemblyId}'}, + {'kind': 'tus-collection', 'parameters': [], 'path': '/resumable/files'}, + {'kind': 'tus-collection', 'parameters': [], 'path': '/resumable/files'}, + {'kind': 'tus-upload-resource', + 'parameters': [{'minLength': 1, + 'name': 'uploadId', + 'percentDecode': True}], + 'path': '/resumable/files/{uploadId}'}, + {'kind': 'tus-upload-resource', + 'parameters': [{'minLength': 1, + 'name': 'uploadId', + 'percentDecode': True}], + 'path': '/resumable/files/{uploadId}'}, + {'kind': 'tus-upload-resource', + 'parameters': [{'minLength': 1, + 'name': 'uploadId', + 'percentDecode': True}], + 'path': '/resumable/files/{uploadId}'}, + {'kind': 'tus-upload-resource', + 'parameters': [{'minLength': 1, + 'name': 'uploadId', + 'percentDecode': True}], + 'path': '/resumable/files/{uploadId}'}], + 'streamField': 'update_stream_url', + 'streamQuery': 'assembly', + 'unsupportedHeaders': ['upload-concat', + 'x-http-method-override', + 'x-method-override'], + 'version': 2}, + 'operations': {'api2.assembly-stats': {'method': 'GET', + 'path': '/assembly_stats', + 'python_method': 'assembly_stats', + 'stage': None}, + 'api2.bulk-delete-dam-assets': {'method': 'POST', + 'path': '/dam/assets/bulk/delete', + 'python_method': 'bulk_delete_dam_assets', + 'stage': 'alpha'}, + 'api2.bulk-move-dam-assets': {'method': 'POST', + 'path': '/dam/assets/bulk/move', + 'python_method': 'bulk_move_dam_assets', + 'stage': 'alpha'}, + 'api2.cancel-assembly': {'method': 'DELETE', + 'path': '/assemblies/{assemblyId}', + 'python_method': 'cancel_assembly', + 'stage': None}, + 'api2.create-assembly': {'method': 'POST', + 'path': '/assemblies', + 'python_method': 'create_assembly', + 'stage': None}, + 'api2.create-auth-key': {'method': 'POST', + 'path': '/auth_keys', + 'python_method': 'create_auth_key', + 'stage': None}, + 'api2.create-template': {'method': 'POST', + 'path': '/templates', + 'python_method': 'create_template', + 'stage': None}, + 'api2.create-template-credential': {'method': 'POST', + 'path': '/template_credentials', + 'python_method': 'create_template_credentials', + 'stage': None}, + 'api2.delete-auth-key': {'method': 'DELETE', + 'path': '/auth_keys/{authKeyId}', + 'python_method': 'delete_auth_key', + 'stage': None}, + 'api2.delete-dam-asset': {'method': 'DELETE', + 'path': '/dam/assets/{assetId}', + 'python_method': 'delete_dam_asset', + 'stage': 'alpha'}, + 'api2.delete-template': {'method': 'DELETE', + 'path': '/templates/{templateIdOrName}', + 'python_method': 'delete_template', + 'stage': None}, + 'api2.delete-template-credential': {'method': 'DELETE', + 'path': '/template_credentials/{templateCredentialId}', + 'python_method': 'delete_template_credentials', + 'stage': None}, + 'api2.get-assembly': {'method': 'GET', + 'path': '/assemblies/{assemblyId}', + 'python_method': 'get_assembly', + 'stage': None}, + 'api2.get-bill': {'method': 'GET', + 'path': '/bill/{billYearMonth}', + 'python_method': 'get_bill', + 'stage': None}, + 'api2.get-dam-asset': {'method': 'GET', + 'path': '/dam/assets/{assetId}', + 'python_method': 'get_dam_asset', + 'stage': None}, + 'api2.get-template': {'method': 'GET', + 'path': '/templates/{templateIdOrName}', + 'python_method': 'get_template', + 'stage': None}, + 'api2.get-template-credential': {'method': 'GET', + 'path': '/template_credentials/{templateCredentialId}', + 'python_method': 'get_template_credentials', + 'stage': None}, + 'api2.issue-bearer-token': {'method': 'POST', + 'path': '/token', + 'python_method': 'issue_bearer_token', + 'stage': None}, + 'api2.list-assemblies': {'method': 'GET', + 'path': '/assemblies', + 'python_method': 'list_assemblies', + 'stage': None}, + 'api2.list-assembly-notifications': {'method': 'GET', + 'path': '/assembly_notifications/{assemblyId}', + 'python_method': 'list_assembly_notifications', + 'stage': None}, + 'api2.list-auth-key-scopes': {'method': 'GET', + 'path': '/auth_keys/scopes', + 'python_method': 'list_auth_key_scopes', + 'stage': None}, + 'api2.list-auth-keys': {'method': 'GET', + 'path': '/auth_keys', + 'python_method': 'list_auth_keys', + 'stage': None}, + 'api2.list-dam-assets': {'method': 'GET', + 'path': '/dam/assets', + 'python_method': 'list_dam_assets', + 'stage': None}, + 'api2.list-priority-job-slots': {'method': 'GET', + 'path': '/queues/job_slots', + 'python_method': 'list_priority_job_slots', + 'stage': None}, + 'api2.list-template-credential-types': {'method': 'GET', + 'path': '/template_credentials/types', + 'python_method': 'list_template_credential_types', + 'stage': None}, + 'api2.list-template-credentials': {'method': 'GET', + 'path': '/template_credentials', + 'python_method': 'list_template_credentials', + 'stage': None}, + 'api2.list-templates': {'method': 'GET', + 'path': '/templates', + 'python_method': 'list_templates', + 'stage': None}, + 'api2.move-dam-asset': {'method': 'PATCH', + 'path': '/dam/assets/{assetId}', + 'python_method': 'move_dam_asset', + 'stage': 'alpha'}, + 'api2.move-dam-entry': {'method': 'POST', + 'path': '/dam/entries/move', + 'python_method': 'move_dam_entry', + 'stage': 'alpha'}, + 'api2.priority-job-slot-stats': {'method': 'GET', + 'path': '/priority_job_slot_stats', + 'python_method': 'priority_job_slot_stats', + 'stage': None}, + 'api2.replace-assembly': {'method': 'PUT', + 'path': '/assemblies/{assemblyId}', + 'python_method': 'replace_assembly', + 'stage': None}, + 'api2.replay-assembly': {'method': 'POST', + 'path': '/assemblies/{assemblyId}/replay', + 'python_method': 'replay_assembly', + 'stage': None}, + 'api2.replay-assembly-notification': {'method': 'POST', + 'path': '/assembly_notifications/{assemblyId}/replay', + 'python_method': 'replay_assembly_notification', + 'stage': None}, + 'api2.show-auth-key-secret': {'method': 'POST', + 'path': '/auth_keys/show_secret/{authKeyId}', + 'python_method': 'show_auth_key_secret', + 'stage': None}, + 'api2.stream-assembly-status': {'method': 'GET', + 'path': '/{statusStream}', + 'python_method': 'stream_assembly_status', + 'stage': None}, + 'api2.update-auth-key': {'method': 'PUT', + 'path': '/auth_keys/{authKeyId}', + 'python_method': 'update_auth_key', + 'stage': None}, + 'api2.update-template': {'method': 'PUT', + 'path': '/templates/{templateIdOrName}', + 'python_method': 'update_template', + 'stage': None}, + 'api2.update-template-credential': {'method': 'PUT', + 'path': '/template_credentials/{templateCredentialId}', + 'python_method': 'update_template_credentials', + 'stage': None}, + 'tusd.create-upload': {'method': 'POST', + 'path': '/resumable/files', + 'python_method': 'create_upload', + 'stage': None}, + 'tusd.delete-upload': {'method': 'DELETE', + 'path': '/resumable/files/{uploadId}', + 'python_method': 'delete_upload', + 'stage': None}, + 'tusd.download-upload': {'method': 'GET', + 'path': '/resumable/files/{uploadId}', + 'python_method': 'download_upload', + 'stage': None}, + 'tusd.get-upload-offset': {'method': 'HEAD', + 'path': '/resumable/files/{uploadId}', + 'python_method': 'get_upload_offset', + 'stage': None}, + 'tusd.options': {'method': 'OPTIONS', + 'path': '/resumable/files', + 'python_method': 'tus_options', + 'stage': None}, + 'tusd.patch-upload': {'method': 'PATCH', + 'path': '/resumable/files/{uploadId}', + 'python_method': 'patch_upload', + 'stage': None}}, + 'protocols': {'tusd.create-upload': {'binary_response': False, + 'defaults': {'tus-resumable': '1.0.0'}, + 'destination': 'tus-collection', + 'method': 'POST'}, + 'tusd.delete-upload': {'binary_response': False, + 'defaults': {'tus-resumable': '1.0.0'}, + 'destination': 'tus-upload-resource', + 'method': 'DELETE'}, + 'tusd.download-upload': {'binary_response': True, + 'defaults': {}, + 'destination': 'tus-upload-resource', + 'method': 'GET'}, + 'tusd.get-upload-offset': {'binary_response': False, + 'defaults': {'tus-resumable': '1.0.0'}, + 'destination': 'tus-upload-resource', + 'method': 'HEAD'}, + 'tusd.options': {'binary_response': False, + 'defaults': {}, + 'destination': 'tus-collection', + 'method': 'OPTIONS'}, + 'tusd.patch-upload': {'binary_response': False, + 'defaults': {'content-type': 'application/offset+octet-stream', + 'tus-resumable': '1.0.0'}, + 'destination': 'tus-upload-resource', + 'method': 'PATCH'}}, + 'stream_events': [{'data': {'$ref': 'urn:transloadit:json-schema:sha256:de7f1223b1c85e19c68ce352fd4ab3febf036a5465c18990d5220a9141770ba8'}, + 'kind': 'event', + 'name': 'assembly_error', + 'terminal': True}, + {'data': {'$ref': 'urn:transloadit:json-schema:sha256:0c63aba5703f317c14e15fc6ee66a489b19331fb048d1673c1f36214fc1fb1dd'}, + 'kind': 'event', + 'name': 'assembly_execution_progress', + 'terminal': False}, + {'kind': 'message', 'name': 'assembly_finished', 'terminal': True}, + {'kind': 'message', 'name': 'ping', 'terminal': False}, + {'data': {'$ref': 'urn:transloadit:json-schema:sha256:dee4880f0fa9a16a80f73b4c01c4613db2bbf83180a2d1ca7726274e619cd05e'}, + 'kind': 'event', + 'name': 'assembly_result_finished', + 'terminal': False}, + {'data': {'$ref': 'urn:transloadit:json-schema:sha256:87244e853c1392a3d720076fd5f9bba476473de64a010e876b589407191efe87'}, + 'kind': 'event', + 'name': 'assembly_upload_finished', + 'terminal': False}, + {'kind': 'message', + 'name': 'assembly_upload_meta_data_extracted', + 'terminal': False}, + {'kind': 'message', 'name': 'assembly_uploading_finished', 'terminal': False}], + 'token_auth': {'field': 'grant_type', + 'values': {'authorization_code': 'none', + 'client_credentials': 'basic', + 'refresh_token': 'none'}}} diff --git a/transloadit/async_client.py b/transloadit/async_client.py index fe9692b..91f512f 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -1,7 +1,7 @@ import asyncio import base64 from typing import Optional -from urllib.parse import quote, urljoin +from urllib.parse import quote from . import async_assembly, async_request, async_template from .api_url import normalize_service_url, require_path_id @@ -20,11 +20,14 @@ def __init__( service: str = "https://api2.transloadit.com", duration: int = 300, session=None, + *, + bearer_token: str = None, ): self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration + self.bearer_token = bearer_token self.request = async_request.AsyncRequest(self, session=session) async def __aenter__(self): @@ -46,11 +49,7 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: """ return async_assembly.AsyncAssembly(self, options=params) - # - # This block is generated from Transloadit API2 contracts. If it looks wrong, - # please report the issue instead of editing this block by hand; the source fix - # belongs in the contract generator so all SDKs stay in sync. - + # Compatibility aliases and capability URL handling are maintained by hand. def _quote_path_segment(self, value: str) -> str: value = str(value) if value in (".", ".."): @@ -121,12 +120,6 @@ async def _request_assembly_url(self, url, method, params=None): headers=raw_response.headers, ) - async def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): - """ - Create a new Assembly. - """ - return await self.request.post("/assemblies", data=data, extra_data=extra_data, files=files) - async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create an Assembly with a chosen ID. @@ -135,248 +128,436 @@ async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = return await self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) - async def list_assemblies(self, params: Optional[dict] = None): + async def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): + """ + Retrieve an invoice’s bill. + """ + date = require_path_id(date, "date") + invoice_id = require_path_id(invoice_id, "invoice_id") + + return await self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) + + async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Retrieve list of Assemblies. + Retrieve full Template details. """ - return await self.request.get("/assemblies", params=params) + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + + return await self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) - async def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params: Optional[dict] = None): + async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Retrieve an Assembly Status. + Retrieve full built-in Template details. """ - if not (assembly_id or assembly_url): - raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return await self._request_assembly_url(url, "GET", params=params) + return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) + + async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + """ + Retrieve a built-in Template. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) + + async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + """ + Validate an OAuth Template Credential name. + """ + return await self.request.post("/template_credentials/validateOauthOnCreate", data=data) + + # + # Generated by scripts/generate_endpoints.py; edit the generator, not this block. + + async def assembly_stats(self, params=None): + """ + Retrieve Assembly statistics + + Contract operation: api2.assembly-stats. + """ + return await self.request.get('/assembly_stats', params=params) + + async def bulk_delete_dam_assets(self, data=None): + """ + Delete DAM assets in bulk + + Contract operation: api2.bulk-delete-dam-assets. + Stage: alpha; this API may change. + """ + return await self.request.post('/dam/assets/bulk/delete', data=data) + + async def bulk_move_dam_assets(self, data=None): + """ + Move DAM assets in bulk - async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): + Contract operation: api2.bulk-move-dam-assets. + Stage: alpha; this API may change. """ - Cancel a running Assembly. + return await self.request.post('/dam/assets/bulk/move', data=data) + + async def cancel_assembly(self, assembly_id=None, assembly_url=None): + """ + Cancel a running Assembly + + Contract operation: api2.cancel-assembly. """ if not (assembly_id or assembly_url): - raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + raise ValueError("Either assembly_id or assembly_url is required.") + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" + return await self._request_assembly_url(url, 'DELETE') + + async def create_assembly(self, data=None, extra_data=None, files=None): + """ + Create a new Assembly + + Contract operation: api2.create-assembly. + """ + return await self.request.post('/assemblies', data=data, extra_data=extra_data, files=files) + + async def create_auth_key(self, data=None): + """ + Create a new Auth Key + + Contract operation: api2.create-auth-key. + """ + return await self.request.post('/auth_keys', data=data) + + async def create_template(self, data=None): + """ + Create a new Template + + Contract operation: api2.create-template. + """ + return await self.request.post('/templates', data=data) + + async def create_template_credentials(self, data=None): + """ + Create a new Template Credential + + Contract operation: api2.create-template-credential. + """ + return await self.request.post('/template_credentials', data=data) + + async def delete_auth_key(self, auth_key_id: str, data=None): + """ + Delete an Auth Key + + Contract operation: api2.delete-auth-key. + """ + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return await self.request.delete(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + + async def delete_dam_asset(self, asset_id: str, data=None): + """ + Delete a DAM asset + + Contract operation: api2.delete-dam-asset. + Stage: alpha; this API may change. + """ + asset_id = require_path_id(asset_id, 'asset_id') + return await self.request.delete(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) + + async def delete_template(self, template_id: str, data=None): + """ + Delete a Template + + Contract operation: api2.delete-template. + """ + template_id = require_path_id(template_id, 'template_id') + return await self.request.delete(f'/templates/{self._quote_path_segment(template_id)}', data=data) + + async def delete_template_credentials(self, identifier: str, data=None): + """ + Delete a Template Credential + + Contract operation: api2.delete-template-credential. + """ + identifier = require_path_id(identifier, 'identifier') + return await self.request.delete(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) + async def get_assembly(self, assembly_id=None, assembly_url=None, params=None): + """ + Retrieve an Assembly Status + + Contract operation: api2.get-assembly. + """ + if not (assembly_id or assembly_url): + raise ValueError("Either assembly_id or assembly_url is required.") url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return await self._request_assembly_url(url, "DELETE") + return await self._request_assembly_url(url, 'GET', params=params) - async def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): + async def get_bill(self, month: int, year: int, params=None): """ - Replay an Assembly. + Retrieve a month’s bill + + Contract operation: api2.get-bill. """ - assembly_id = require_path_id(assembly_id, "assembly_id") + return await self.request.get(f'/bill/{year}-{month:02d}', params=params) - return await self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}/replay", data=data) + async def get_dam_asset(self, asset_id: str, params=None): + """ + Retrieve a Storage asset - async def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): + Contract operation: api2.get-dam-asset. """ - Replay Assembly Notification. + asset_id = require_path_id(asset_id, 'asset_id') + return await self.request.get(f'/dam/assets/{self._quote_path_segment(asset_id)}', params=params) + + async def get_template(self, template_id: str, params=None): """ - assembly_id = require_path_id(assembly_id, "assembly_id") + Retrieve a Template - return await self.request.post(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay", data=data) + Contract operation: api2.get-template. + """ + template_id = require_path_id(template_id, 'template_id') + return await self.request.get(f'/templates/{self._quote_path_segment(template_id)}', params=params) - async def list_assembly_notifications(self, assembly_id: str): + async def get_template_credentials(self, identifier: str, params=None): """ - Retrieve Assembly Notifications. + Retrieve a Template Credential + + Contract operation: api2.get-template-credential. """ - assembly_id = require_path_id(assembly_id, "assembly_id") + identifier = require_path_id(identifier, 'identifier') + return await self.request.get(f'/template_credentials/{self._quote_path_segment(identifier)}', params=params) - return await self.request.get(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}") + async def issue_bearer_token(self, data=None): + """ + Create a bearer token - async def get_bill(self, month: int, year: int, params: Optional[dict] = None): + Contract operation: api2.issue-bearer-token. """ - Retrieve a month’s bill. + return await self.request.issue_bearer_token(data) + + async def list_assemblies(self, params=None): """ - return await self.request.get(f"/bill/{year}-{month:02d}", params=params) + Retrieve list of Assemblies - async def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): + Contract operation: api2.list-assemblies. """ - Retrieve an invoice’s bill. + return await self.request.get('/assemblies', params=params) + + async def list_assembly_notifications(self, assembly_id: str, params=None): """ - date = require_path_id(date, "date") - invoice_id = require_path_id(invoice_id, "invoice_id") + Retrieve Assembly Notifications - return await self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) + Contract operation: api2.list-assembly-notifications. + """ + assembly_id = require_path_id(assembly_id, 'assembly_id') + return await self.request.public('GET', f'/assembly_notifications/{self._quote_path_segment(assembly_id)}', params=params) - async def list_templates(self, params: Optional[dict] = None): + async def list_auth_key_scopes(self, params=None): """ - Retrieve list of Templates. + Retrieve Auth Key scopes + + Contract operation: api2.list-auth-key-scopes. """ - return await self.request.get("/templates", params=params) + return await self.request.get('/auth_keys/scopes', params=params) - async def create_template(self, data: Optional[dict] = None): + async def list_auth_keys(self, params=None): """ - Create a new Template. + Retrieve list of Auth Keys + + Contract operation: api2.list-auth-keys. """ - return await self.request.post("/templates", data=data) + return await self.request.get('/auth_keys', params=params) - async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): + async def list_dam_assets(self, params=None): """ - Retrieve full Template details. + List Storage assets + + Contract operation: api2.list-dam-assets. """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + return await self.request.get('/dam/assets', params=params) - return await self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) + async def list_priority_job_slots(self, params=None): + """ + Retrieve currently used priority job slots - async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): + Contract operation: api2.list-priority-job-slots. """ - Retrieve full built-in Template details. + return await self.request.get('/queues/job_slots', params=params) + + async def list_template_credential_types(self, params=None): """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + Retrieve Template Credential types - return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) + Contract operation: api2.list-template-credential-types. + """ + return await self.request.get('/template_credentials/types', params=params) - async def get_template(self, template_id: str, params: Optional[dict] = None): + async def list_template_credentials(self, params=None): """ - Retrieve a Template. + Retrieve list of Template Credentials + + Contract operation: api2.list-template-credentials. """ - template_id = require_path_id(template_id, "template_id") + return await self.request.get('/template_credentials', params=params) - return await self.request.get(f"/templates/{self._quote_path_segment(template_id)}", params=params) + async def list_templates(self, params=None): + """ + Retrieve list of Templates - async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + Contract operation: api2.list-templates. """ - Retrieve a built-in Template. + return await self.request.get('/templates', params=params) + + async def move_dam_asset(self, asset_id: str, data=None): """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + Move or rename a DAM asset - return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) + Contract operation: api2.move-dam-asset. + Stage: alpha; this API may change. + """ + asset_id = require_path_id(asset_id, 'asset_id') + return await self.request.patch(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - async def update_template(self, template_id: str, data: Optional[dict] = None): + async def move_dam_entry(self, data=None): """ - Edit a Template. + Move a Storage file or folder + + Contract operation: api2.move-dam-entry. + Stage: alpha; this API may change. """ - template_id = require_path_id(template_id, "template_id") + return await self.request.post('/dam/entries/move', data=data) - return await self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) + async def priority_job_slot_stats(self, params=None): + """ + Retrieve priority job slot statistics - async def delete_template(self, template_id: str, data: Optional[dict] = None): + Contract operation: api2.priority-job-slot-stats. """ - Delete a Template. + return await self.request.get('/priority_job_slot_stats', params=params) + + async def replace_assembly(self, assembly_id: str, data=None, extra_data=None, files=None): """ - template_id = require_path_id(template_id, "template_id") + Create an Assembly with a supplied ID - return await self.request.delete(f"/templates/{self._quote_path_segment(template_id)}", data=data) + Contract operation: api2.replace-assembly. + """ + assembly_id = require_path_id(assembly_id, 'assembly_id') + return await self.request.put(f'/assemblies/{self._quote_path_segment(assembly_id)}', data=data, extra_data=extra_data, files=files) - async def list_priority_job_slots(self, params: Optional[dict] = None): + async def replay_assembly(self, assembly_id: str, data=None): """ - Retrieve currently used priority job slots. + Replay an Assembly + + Contract operation: api2.replay-assembly. """ - return await self.request.get("/queues/job_slots", params=params) + assembly_id = require_path_id(assembly_id, 'assembly_id') + return await self.request.post(f'/assemblies/{self._quote_path_segment(assembly_id)}/replay', data=data) - async def issue_bearer_token(self, data: Optional[dict] = None): + async def replay_assembly_notification(self, assembly_id: str, data=None): """ - Create a bearer token. + Replay Assembly Notification + + Contract operation: api2.replay-assembly-notification. """ - if not self.auth_secret: - raise ValueError("Bearer token issuance requires an auth secret.") + assembly_id = require_path_id(assembly_id, 'assembly_id') + return await self.request.post(f'/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay', data=data) - from ipaddress import ip_address - from urllib.parse import urlparse + async def show_auth_key_secret(self, auth_key_id: str, data=None): + """ + Retrieve an Auth Key secret - endpoint = urlparse(self.service) - try: - loopback = endpoint.hostname == "localhost" or ip_address( - endpoint.hostname or "" - ).is_loopback - except ValueError: - loopback = False - if ( - endpoint.username is not None - or endpoint.password is not None - or not (endpoint.scheme == "https" or (endpoint.scheme == "http" and loopback)) - ): - raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") - - data = data or {} - form_data = {} - if data.get("aud") is not None: - form_data["aud"] = data["aud"] - form_data["grant_type"] = "client_credentials" - if data.get("scope") is not None: - form_data["scope"] = data["scope"] - - credentials = base64.b64encode( - f"{self.auth_key}:{self.auth_secret}".encode("utf-8") - ).decode("ascii") - headers = { - "Accept": "application/json", - "Authorization": f"Basic {credentials}", - "Content-Type": "application/x-www-form-urlencoded", - } - headers.update(self.request._headers()) - session = await self.request._ensure_session() - async with session.post( - self.service.rstrip("/") + "/token", - data=form_data, - headers=headers, - timeout=self.request._timeout(), - allow_redirects=False, - ) as raw_response: - from .response import Response + Contract operation: api2.show-auth-key-secret. + """ + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return await self.request.post(f'/auth_keys/show_secret/{self._quote_path_segment(auth_key_id)}', data=data) - return Response( - data=await self.request._read_response_data(raw_response), - status_code=raw_response.status, - headers=raw_response.headers, - ) + def stream_assembly_status(self, stream_url, *, read_timeout=120, max_event_size=1048576): + """ + Stream Assembly changes live - async def list_template_credentials(self, params: Optional[dict] = None): + Contract operation: api2.stream-assembly-status. + Use with a context manager. Terminal events do not imply Assembly success. """ - Retrieve list of Template Credentials. + return self.request.stream_status(stream_url, read_timeout=read_timeout, max_event_size=max_event_size) + + async def update_auth_key(self, auth_key_id: str, data=None): """ - return await self.request.get("/template_credentials", params=params) + Edit an Auth Key - async def list_template_credential_types(self, params: Optional[dict] = None): + Contract operation: api2.update-auth-key. """ - Retrieve Template Credential types. + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return await self.request.put(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + + async def update_template(self, template_id: str, data=None): """ - return await self.request.get("/template_credentials/types", params=params) + Edit a Template - async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + Contract operation: api2.update-template. """ - Validate an OAuth Template Credential name. + template_id = require_path_id(template_id, 'template_id') + return await self.request.put(f'/templates/{self._quote_path_segment(template_id)}', data=data) + + async def update_template_credentials(self, identifier: str, data=None): """ - return await self.request.post("/template_credentials/validateOauthOnCreate", data=data) + Edit a Template Credential + + Contract operation: api2.update-template-credential. + """ + identifier = require_path_id(identifier, 'identifier') + return await self.request.put(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) - async def create_template_credentials(self, data: Optional[dict] = None): + async def create_upload(self, assembly, headers=None, body=None): """ - Create a new Template Credential. + Create a tus upload + + Contract operation: tusd.create-upload. + Pass protocol headers using headers; binary downloads return bytes. """ - return await self.request.post("/template_credentials", data=data) + return await self.request.tus('tusd.create-upload', assembly, headers=headers, body=body) - async def get_template_credentials(self, identifier: str, params: Optional[dict] = None): + async def delete_upload(self, upload_url, headers=None): """ - Retrieve a Template Credential. + Terminate a tus upload + + Contract operation: tusd.delete-upload. + Pass protocol headers using headers; binary downloads return bytes. """ - identifier = require_path_id(identifier, "identifier") + return await self.request.tus('tusd.delete-upload', upload_url, headers=headers, body=None) - return await self.request.get(f"/template_credentials/{self._quote_path_segment(identifier)}", params=params) + async def download_upload(self, upload_url, headers=None): + """ + Download a tus upload - async def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): + Contract operation: tusd.download-upload. + Pass protocol headers using headers; binary downloads return bytes. """ - Delete a Template Credential. + return await self.request.tus('tusd.download-upload', upload_url, headers=headers, body=None) + + async def get_upload_offset(self, upload_url, headers=None): """ - identifier = require_path_id(identifier, "identifier") + Retrieve a tus upload offset - return await self.request.delete(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) + Contract operation: tusd.get-upload-offset. + Pass protocol headers using headers; binary downloads return bytes. + """ + return await self.request.tus('tusd.get-upload-offset', upload_url, headers=headers, body=None) - async def update_template_credentials(self, identifier: str, data: Optional[dict] = None): + async def tus_options(self, assembly, headers=None): """ - Edit a Template Credential. + Discover tus capabilities + + Contract operation: tusd.options. + Pass protocol headers using headers; binary downloads return bytes. """ - identifier = require_path_id(identifier, "identifier") + return await self.request.tus('tusd.options', assembly, headers=headers, body=None) - return await self.request.put(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) + async def patch_upload(self, upload_url, headers=None, body=None): + """ + Upload tus file bytes + Contract operation: tusd.patch-upload. + Pass protocol headers using headers; binary downloads return bytes. + """ + return await self.request.tus('tusd.patch-upload', upload_url, headers=headers, body=body) # - # - # This block is generated from Transloadit API2 contracts. If it looks wrong, - # please report the issue instead of editing this block by hand; the source fix - # belongs in the contract generator so all SDKs stay in sync. + # High-level upload/resume workflows are maintained by hand. async def create_tus_assembly(self, file_count: int): """ @@ -401,125 +582,36 @@ async def create_tus_assembly(self, file_count: int): return assembly async def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): - """ - Resumes an interrupted TUS upload from the server-reported offset and waits for the Assembly to finish. - """ - stored_upload_url = upload_url - if not stored_upload_url: - raise RuntimeError("TUS resumeUpload needs input.storedUploadUrl") - - session = await self.request._ensure_session() - - offset_headers = {} - offset_headers["Tus-Resumable"] = "1.0.0" - async with session.request( - "HEAD", - stored_upload_url, - data=b"", - headers=offset_headers, - timeout=self.request._timeout(), - ) as offset_response: - if offset_response.status != 200: - raise RuntimeError(f"TUS offset returned HTTP {offset_response.status}, expected 200") - resume_offset_header = offset_response.headers.get("Upload-Offset") - if not resume_offset_header: - raise RuntimeError("TUS offset did not return a Upload-Offset header") - try: - resume_offset = int(resume_offset_header) - except ValueError as error: - raise RuntimeError("TUS offset returned an invalid Upload-Offset header") from error - - upload_headers = {} - upload_headers["Tus-Resumable"] = "1.0.0" - upload_headers["Upload-Offset"] = str(resume_offset) - upload_headers["Content-Type"] = "application/offset+octet-stream" - async with session.request( - "PATCH", - stored_upload_url, - data=content[resume_offset:], - headers=upload_headers, - timeout=self.request._timeout(), - ) as upload_response: - if upload_response.status != 204: - raise RuntimeError(f"TUS upload returned HTTP {upload_response.status}, expected 204") - try: - upload_offset = int(upload_response.headers.get("Upload-Offset", "")) - except ValueError as error: - raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if upload_offset != len(content): - raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - - completed_assembly = await self.wait_for_assembly(assembly_ssl_url) - - return completed_assembly + """Resume from the reported offset, then poll the Assembly to completion.""" + offset_response = await self.get_upload_offset(upload_url) + if offset_response.status_code != 200: + raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}") + try: + offset = int(offset_response.headers.get("Upload-Offset", "")) + except ValueError: + raise RuntimeError("TUS offset is not an integer.") from None + if not 0 <= offset <= len(content): + raise RuntimeError("TUS offset is outside the supplied content.") + response = await self.patch_upload(upload_url, headers={"Upload-Offset": str(offset)}, body=content[offset:]) + if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): + raise RuntimeError("TUS resume did not acknowledge the complete content.") + return await self.wait_for_assembly(assembly_ssl_url) async def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): - """ - Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. - """ - created_assembly = await self.create_tus_assembly(1) - - endpoint_url = created_assembly.data.get("tus_url") - if not endpoint_url: - raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") - - metadata_map = {} - if user_meta: - metadata_map.update({str(key): str(value) for key, value in user_meta.items()}) - metadata_map["assembly_url"] = str(created_assembly.data.get("assembly_ssl_url")) - metadata_map["fieldname"] = str(fieldname) - metadata_map["filename"] = str(filename) - - session = await self.request._ensure_session() - - create_headers = {} - create_headers["Tus-Resumable"] = "1.0.0" - create_headers["Upload-Length"] = str(len(content)) - create_metadata_parts = [] - for key, value in metadata_map.items(): - encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") - create_metadata_parts.append(f"{key} {encoded_value}") - create_headers["Upload-Metadata"] = ",".join(create_metadata_parts) - async with session.request( - "POST", - endpoint_url, - data=b"", - headers=create_headers, - timeout=self.request._timeout(), - ) as create_response: - if create_response.status != 201: - raise RuntimeError(f"TUS create returned HTTP {create_response.status}, expected 201") - upload_url_location = create_response.headers.get("Location") - if not upload_url_location: - raise RuntimeError("TUS create did not return a Location header") - upload_url_text = urljoin(endpoint_url, upload_url_location) - - upload_headers = {} - upload_headers["Tus-Resumable"] = "1.0.0" - upload_headers["Upload-Offset"] = "0" - upload_headers["Content-Type"] = "application/offset+octet-stream" - async with session.request( - "PATCH", - upload_url_text, - data=content, - headers=upload_headers, - timeout=self.request._timeout(), - ) as upload_response: - if upload_response.status != 204: - raise RuntimeError(f"TUS upload returned HTTP {upload_response.status}, expected 204") - try: - upload_offset = int(upload_response.headers.get("Upload-Offset", "")) - except ValueError as error: - raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if upload_offset != len(content): - raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - - created_assembly_assembly_ssl_url = created_assembly.data.get("assembly_ssl_url") - if not created_assembly_assembly_ssl_url: - raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") - completed_assembly = await self.wait_for_assembly(created_assembly_assembly_ssl_url) - - return completed_assembly, upload_url_text + """Create an Assembly, upload one file using TUS, and wait for completion.""" + assembly = await self.create_tus_assembly(1) + metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} + metadata.update({"fieldname": fieldname, "filename": filename}) + encoded = ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") + for key, value in metadata.items()) + created = await self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) + if created.status_code != 201: + raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") + response = await self.patch_upload(created.upload_url, headers={"Upload-Offset": "0"}, body=content) + if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): + raise RuntimeError("TUS upload did not acknowledge the complete content.") + completed = await self.wait_for_assembly(assembly.data["assembly_ssl_url"]) + return completed, created.upload_url async def wait_for_assembly(self, assembly_url: str): """ @@ -543,7 +635,6 @@ async def wait_for_assembly(self, assembly_url: str): await asyncio.sleep(1) - # def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: """ diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 65f8495..bc528e8 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -7,6 +7,7 @@ import mimetypes import os from datetime import datetime, timedelta, timezone +from contextlib import asynccontextmanager from types import MappingProxyType import aiohttp @@ -14,7 +15,9 @@ from . import __version__ from .api_url import should_sign_api_url +from .endpoint_transport import capability_url, token_request, tus_request, validate_upload_location from .response import Response +from .stream import EventParser, StreamError from .upload import get_upload_filename TIMEOUT = 60 @@ -85,8 +88,11 @@ def __init__(self, transloadit, session=None): def session(self): return self._session - def _headers(self): - return dict(self.HEADERS) + def _headers(self, url=None): + headers = dict(self.HEADERS) + if url and getattr(self.transloadit, "bearer_token", None) and should_sign_api_url(url, self.transloadit.service): + headers["Authorization"] = "Bearer " + self.transloadit.bearer_token + return headers def _get_session_lock(self): if self._session_lock is None: @@ -152,8 +158,9 @@ async def get(self, path, params=None): async with session.get( url, params=self._to_request_payload(url, params), - headers=self._headers(), + headers=self._headers(url), timeout=self._timeout(), + allow_redirects=False, ) as response: return Response( data=await self._read_response_data(response), @@ -165,6 +172,9 @@ async def post(self, path, data=None, extra_data=None, files=None): """ Makes an asynchronous HTTP POST request. """ + return await self._form_request("post", path, data, extra_data, files) + + async def _form_request(self, method, path, data=None, extra_data=None, files=None): url = self._get_full_url(path) session = await self._ensure_session() data = self._to_request_payload(url, data) or {} @@ -189,11 +199,12 @@ async def post(self, path, data=None, extra_data=None, files=None): else: payload = self._normalize_payload(data) - async with session.post( + async with getattr(session, method)( url, data=payload, - headers=self._headers(), + headers=self._headers(url), timeout=self._timeout(), + allow_redirects=False, ) as response: return Response( data=await self._read_response_data(response), @@ -201,24 +212,14 @@ async def post(self, path, data=None, extra_data=None, files=None): headers=CaseInsensitiveDict(response.headers), ) - async def put(self, path, data=None): + async def put(self, path, data=None, extra_data=None, files=None): """ Makes an asynchronous HTTP PUT request. """ - url = self._get_full_url(path) - session = await self._ensure_session() - data = self._normalize_payload(self._to_request_payload(url, data) or {}) - async with session.put( - url, - data=data, - headers=self._headers(), - timeout=self._timeout(), - ) as response: - return Response( - data=await self._read_response_data(response), - status_code=response.status, - headers=CaseInsensitiveDict(response.headers), - ) + return await self._form_request("put", path, data, extra_data, files) + + async def patch(self, path, data=None): + return await self._form_request("patch", path, data) async def delete(self, path, data=None): """ @@ -230,8 +231,9 @@ async def delete(self, path, data=None): async with session.delete( url, data=data, - headers=self._headers(), + headers=self._headers(url), timeout=self._timeout(), + allow_redirects=False, ) as response: return Response( data=await self._read_response_data(response), @@ -241,6 +243,8 @@ async def delete(self, path, data=None): def _to_payload(self, data): data = copy.deepcopy(data or {}) + if getattr(self.transloadit, "bearer_token", None): + return {"params": json.dumps(data)} expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) if "auth" in data and not isinstance(data["auth"], dict): raise ValueError("auth must be a dictionary when provided.") @@ -268,3 +272,55 @@ def _get_full_url(self, url): if url.startswith(("http://", "https://")): return url return self.transloadit.service + url + + async def public(self, method, path, params=None, data=None): + # A separate session prevents injected session cookies/auth from leaking + # onto credential-free capability and public endpoints. + async with aiohttp.ClientSession(trust_env=False) as session: + async with session.request(method, self._get_full_url(path), params=params, data=data, + headers=self._headers(), timeout=self._timeout(), allow_redirects=False) as response: + return Response(data=await self._read_response_data(response), status_code=response.status, + headers=CaseInsensitiveDict(response.headers)) + + async def issue_bearer_token(self, data=None): + url, data, headers = token_request(self.transloadit, data) + headers.update(self._headers()) + async with aiohttp.ClientSession(trust_env=False) as session: + async with session.post(url, data=self._normalize_payload(data), headers=headers, + timeout=self._timeout(), allow_redirects=False) as response: + return Response(data=await self._read_response_data(response), status_code=response.status, + headers=CaseInsensitiveDict(response.headers)) + + async def tus(self, operation_id, location, headers=None, body=None): + spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) + headers.update(self._headers()) + async with aiohttp.ClientSession(trust_env=False) as session: + async with session.request(spec["method"], url, data=body, headers=headers, + timeout=self._timeout(), allow_redirects=False) as raw: + data = await raw.read() if spec["binary_response"] else await self._read_response_data(raw) + response = Response(data=data, status_code=raw.status, headers=CaseInsensitiveDict(raw.headers)) + if spec["method"] == "POST": + validate_upload_location(self.transloadit, url, response) + return response + + @asynccontextmanager + async def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): + url = capability_url(self.transloadit, url, "status-stream") + parser = EventParser(max_event_size) + timeout = aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=read_timeout) + async with aiohttp.ClientSession(trust_env=False) as session: + async with session.get(url, headers={**self._headers(), "Accept": "text/event-stream"}, + timeout=timeout, allow_redirects=False) as response: + if response.status != 200: + raise StreamError(response.status) + if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": + raise StreamError(response.status, "Expected text/event-stream") + + async def events(): + async for chunk in response.content.iter_any(): + for event in parser.feed(chunk): + yield event + if event.terminal: + return + + yield events() diff --git a/transloadit/client.py b/transloadit/client.py index 907bbef..993209a 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -2,7 +2,7 @@ import typing from time import sleep from typing import Optional -from urllib.parse import quote, urljoin +from urllib.parse import quote import requests @@ -42,11 +42,14 @@ def __init__( auth_secret: str, service: str = "https://api2.transloadit.com", duration: int = 300, + *, + bearer_token: str = None, ): self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration + self.bearer_token = bearer_token self.request = request.Request(self) def new_assembly(self, params: dict = None) -> assembly.Assembly: @@ -56,11 +59,7 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: """ return assembly.Assembly(self, options=params) - # - # This block is generated from Transloadit API2 contracts. If it looks wrong, - # please report the issue instead of editing this block by hand; the source fix - # belongs in the contract generator so all SDKs stay in sync. - + # Compatibility aliases and capability URL handling are maintained by hand. def _quote_path_segment(self, value: str) -> str: value = str(value) if value in (".", ".."): @@ -126,12 +125,6 @@ def _request_assembly_url(self, url, method, params=None): return Response(raw_response) - def create_assembly(self, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): - """ - Create a new Assembly. - """ - return self.request.post("/assemblies", data=data, extra_data=extra_data, files=files) - def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ Create an Assembly with a chosen ID. @@ -140,243 +133,436 @@ def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, return self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) - def list_assemblies(self, params: Optional[dict] = None): + def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): """ - Retrieve list of Assemblies. + Retrieve an invoice’s bill. """ - return self.request.get("/assemblies", params=params) + date = require_path_id(date, "date") + invoice_id = require_path_id(invoice_id, "invoice_id") - def get_assembly(self, assembly_id: str = None, assembly_url: str = None, params: Optional[dict] = None): + return self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) + + def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): """ - Retrieve an Assembly Status. + Retrieve full Template details. """ - if not (assembly_id or assembly_url): - raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return self._request_assembly_url(url, "GET", params=params) + return self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) - def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): + def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): """ - Cancel a running Assembly. + Retrieve full built-in Template details. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) + + def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + """ + Retrieve a built-in Template. + """ + builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + + return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) + + def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + """ + Validate an OAuth Template Credential name. + """ + return self.request.post("/template_credentials/validateOauthOnCreate", data=data) + + # + # Generated by scripts/generate_endpoints.py; edit the generator, not this block. + + def assembly_stats(self, params=None): + """ + Retrieve Assembly statistics + + Contract operation: api2.assembly-stats. + """ + return self.request.get('/assembly_stats', params=params) + + def bulk_delete_dam_assets(self, data=None): + """ + Delete DAM assets in bulk + + Contract operation: api2.bulk-delete-dam-assets. + Stage: alpha; this API may change. + """ + return self.request.post('/dam/assets/bulk/delete', data=data) + + def bulk_move_dam_assets(self, data=None): + """ + Move DAM assets in bulk + + Contract operation: api2.bulk-move-dam-assets. + Stage: alpha; this API may change. + """ + return self.request.post('/dam/assets/bulk/move', data=data) + + def cancel_assembly(self, assembly_id=None, assembly_url=None): + """ + Cancel a running Assembly + + Contract operation: api2.cancel-assembly. """ if not (assembly_id or assembly_url): - raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") + raise ValueError("Either assembly_id or assembly_url is required.") + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" + return self._request_assembly_url(url, 'DELETE') + + def create_assembly(self, data=None, extra_data=None, files=None): + """ + Create a new Assembly + + Contract operation: api2.create-assembly. + """ + return self.request.post('/assemblies', data=data, extra_data=extra_data, files=files) + + def create_auth_key(self, data=None): + """ + Create a new Auth Key + + Contract operation: api2.create-auth-key. + """ + return self.request.post('/auth_keys', data=data) + + def create_template(self, data=None): + """ + Create a new Template + + Contract operation: api2.create-template. + """ + return self.request.post('/templates', data=data) + + def create_template_credentials(self, data=None): + """ + Create a new Template Credential + + Contract operation: api2.create-template-credential. + """ + return self.request.post('/template_credentials', data=data) + + def delete_auth_key(self, auth_key_id: str, data=None): + """ + Delete an Auth Key + + Contract operation: api2.delete-auth-key. + """ + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return self.request.delete(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + + def delete_dam_asset(self, asset_id: str, data=None): + """ + Delete a DAM asset + + Contract operation: api2.delete-dam-asset. + Stage: alpha; this API may change. + """ + asset_id = require_path_id(asset_id, 'asset_id') + return self.request.delete(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) + def delete_template(self, template_id: str, data=None): + """ + Delete a Template + + Contract operation: api2.delete-template. + """ + template_id = require_path_id(template_id, 'template_id') + return self.request.delete(f'/templates/{self._quote_path_segment(template_id)}', data=data) + + def delete_template_credentials(self, identifier: str, data=None): + """ + Delete a Template Credential + + Contract operation: api2.delete-template-credential. + """ + identifier = require_path_id(identifier, 'identifier') + return self.request.delete(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) + + def get_assembly(self, assembly_id=None, assembly_url=None, params=None): + """ + Retrieve an Assembly Status + + Contract operation: api2.get-assembly. + """ + if not (assembly_id or assembly_url): + raise ValueError("Either assembly_id or assembly_url is required.") url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return self._request_assembly_url(url, "DELETE") + return self._request_assembly_url(url, 'GET', params=params) - def replay_assembly(self, assembly_id: str, data: Optional[dict] = None): + def get_bill(self, month: int, year: int, params=None): """ - Replay an Assembly. + Retrieve a month’s bill + + Contract operation: api2.get-bill. """ - assembly_id = require_path_id(assembly_id, "assembly_id") + return self.request.get(f'/bill/{year}-{month:02d}', params=params) - return self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}/replay", data=data) + def get_dam_asset(self, asset_id: str, params=None): + """ + Retrieve a Storage asset - def replay_assembly_notification(self, assembly_id: str, data: Optional[dict] = None): + Contract operation: api2.get-dam-asset. """ - Replay Assembly Notification. + asset_id = require_path_id(asset_id, 'asset_id') + return self.request.get(f'/dam/assets/{self._quote_path_segment(asset_id)}', params=params) + + def get_template(self, template_id: str, params=None): """ - assembly_id = require_path_id(assembly_id, "assembly_id") + Retrieve a Template - return self.request.post(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay", data=data) + Contract operation: api2.get-template. + """ + template_id = require_path_id(template_id, 'template_id') + return self.request.get(f'/templates/{self._quote_path_segment(template_id)}', params=params) - def list_assembly_notifications(self, assembly_id: str): + def get_template_credentials(self, identifier: str, params=None): """ - Retrieve Assembly Notifications. + Retrieve a Template Credential + + Contract operation: api2.get-template-credential. """ - assembly_id = require_path_id(assembly_id, "assembly_id") + identifier = require_path_id(identifier, 'identifier') + return self.request.get(f'/template_credentials/{self._quote_path_segment(identifier)}', params=params) - return self.request.get(f"/assembly_notifications/{self._quote_path_segment(assembly_id)}") + def issue_bearer_token(self, data=None): + """ + Create a bearer token - def get_bill(self, month: int, year: int, params: Optional[dict] = None): + Contract operation: api2.issue-bearer-token. """ - Retrieve a month’s bill. + return self.request.issue_bearer_token(data) + + def list_assemblies(self, params=None): """ - return self.request.get(f"/bill/{year}-{month:02d}", params=params) + Retrieve list of Assemblies - def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): + Contract operation: api2.list-assemblies. """ - Retrieve an invoice’s bill. + return self.request.get('/assemblies', params=params) + + def list_assembly_notifications(self, assembly_id: str, params=None): """ - date = require_path_id(date, "date") - invoice_id = require_path_id(invoice_id, "invoice_id") + Retrieve Assembly Notifications - return self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) + Contract operation: api2.list-assembly-notifications. + """ + assembly_id = require_path_id(assembly_id, 'assembly_id') + return self.request.public('GET', f'/assembly_notifications/{self._quote_path_segment(assembly_id)}', params=params) - def list_templates(self, params: Optional[dict] = None): + def list_auth_key_scopes(self, params=None): """ - Retrieve list of Templates. + Retrieve Auth Key scopes + + Contract operation: api2.list-auth-key-scopes. """ - return self.request.get("/templates", params=params) + return self.request.get('/auth_keys/scopes', params=params) - def create_template(self, data: Optional[dict] = None): + def list_auth_keys(self, params=None): """ - Create a new Template. + Retrieve list of Auth Keys + + Contract operation: api2.list-auth-keys. """ - return self.request.post("/templates", data=data) + return self.request.get('/auth_keys', params=params) - def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): + def list_dam_assets(self, params=None): """ - Retrieve full Template details. + List Storage assets + + Contract operation: api2.list-dam-assets. """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") + return self.request.get('/dam/assets', params=params) - return self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) + def list_priority_job_slots(self, params=None): + """ + Retrieve currently used priority job slots - def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): + Contract operation: api2.list-priority-job-slots. """ - Retrieve full built-in Template details. + return self.request.get('/queues/job_slots', params=params) + + def list_template_credential_types(self, params=None): """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + Retrieve Template Credential types - return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) + Contract operation: api2.list-template-credential-types. + """ + return self.request.get('/template_credentials/types', params=params) - def get_template(self, template_id: str, params: Optional[dict] = None): + def list_template_credentials(self, params=None): """ - Retrieve a Template. + Retrieve list of Template Credentials + + Contract operation: api2.list-template-credentials. """ - template_id = require_path_id(template_id, "template_id") + return self.request.get('/template_credentials', params=params) - return self.request.get(f"/templates/{self._quote_path_segment(template_id)}", params=params) + def list_templates(self, params=None): + """ + Retrieve list of Templates - def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): + Contract operation: api2.list-templates. """ - Retrieve a built-in Template. + return self.request.get('/templates', params=params) + + def move_dam_asset(self, asset_id: str, data=None): """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") + Move or rename a DAM asset - return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) + Contract operation: api2.move-dam-asset. + Stage: alpha; this API may change. + """ + asset_id = require_path_id(asset_id, 'asset_id') + return self.request.patch(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - def update_template(self, template_id: str, data: Optional[dict] = None): + def move_dam_entry(self, data=None): """ - Edit a Template. + Move a Storage file or folder + + Contract operation: api2.move-dam-entry. + Stage: alpha; this API may change. """ - template_id = require_path_id(template_id, "template_id") + return self.request.post('/dam/entries/move', data=data) - return self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) + def priority_job_slot_stats(self, params=None): + """ + Retrieve priority job slot statistics - def delete_template(self, template_id: str, data: Optional[dict] = None): + Contract operation: api2.priority-job-slot-stats. """ - Delete a Template. + return self.request.get('/priority_job_slot_stats', params=params) + + def replace_assembly(self, assembly_id: str, data=None, extra_data=None, files=None): """ - template_id = require_path_id(template_id, "template_id") + Create an Assembly with a supplied ID - return self.request.delete(f"/templates/{self._quote_path_segment(template_id)}", data=data) + Contract operation: api2.replace-assembly. + """ + assembly_id = require_path_id(assembly_id, 'assembly_id') + return self.request.put(f'/assemblies/{self._quote_path_segment(assembly_id)}', data=data, extra_data=extra_data, files=files) - def list_priority_job_slots(self, params: Optional[dict] = None): + def replay_assembly(self, assembly_id: str, data=None): """ - Retrieve currently used priority job slots. + Replay an Assembly + + Contract operation: api2.replay-assembly. """ - return self.request.get("/queues/job_slots", params=params) + assembly_id = require_path_id(assembly_id, 'assembly_id') + return self.request.post(f'/assemblies/{self._quote_path_segment(assembly_id)}/replay', data=data) - def issue_bearer_token(self, data: Optional[dict] = None): + def replay_assembly_notification(self, assembly_id: str, data=None): """ - Create a bearer token. + Replay Assembly Notification + + Contract operation: api2.replay-assembly-notification. """ - if not self.auth_secret: - raise ValueError("Bearer token issuance requires an auth secret.") + assembly_id = require_path_id(assembly_id, 'assembly_id') + return self.request.post(f'/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay', data=data) - from ipaddress import ip_address - from urllib.parse import urlparse + def show_auth_key_secret(self, auth_key_id: str, data=None): + """ + Retrieve an Auth Key secret - endpoint = urlparse(self.service) - try: - loopback = endpoint.hostname == "localhost" or ip_address( - endpoint.hostname or "" - ).is_loopback - except ValueError: - loopback = False - if ( - endpoint.username is not None - or endpoint.password is not None - or not (endpoint.scheme == "https" or (endpoint.scheme == "http" and loopback)) - ): - raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") - - data = data or {} - form_data = {} - if data.get("aud") is not None: - form_data["aud"] = data["aud"] - form_data["grant_type"] = "client_credentials" - if data.get("scope") is not None: - form_data["scope"] = data["scope"] - - credentials = base64.b64encode( - f"{self.auth_key}:{self.auth_secret}".encode("utf-8") - ).decode("ascii") - headers = { - "Accept": "application/json", - "Authorization": f"Basic {credentials}", - "Content-Type": "application/x-www-form-urlencoded", - } - headers.update(self.request.HEADERS) - raw_response = requests.post( - self.service.rstrip("/") + "/token", - data=form_data, - headers=headers, - timeout=request.TIMEOUT, - allow_redirects=False, - ) - from .response import Response + Contract operation: api2.show-auth-key-secret. + """ + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return self.request.post(f'/auth_keys/show_secret/{self._quote_path_segment(auth_key_id)}', data=data) - return Response(raw_response) + def stream_assembly_status(self, stream_url, *, read_timeout=120, max_event_size=1048576): + """ + Stream Assembly changes live - def list_template_credentials(self, params: Optional[dict] = None): + Contract operation: api2.stream-assembly-status. + Use with a context manager. Terminal events do not imply Assembly success. """ - Retrieve list of Template Credentials. + return self.request.stream_status(stream_url, read_timeout=read_timeout, max_event_size=max_event_size) + + def update_auth_key(self, auth_key_id: str, data=None): """ - return self.request.get("/template_credentials", params=params) + Edit an Auth Key - def list_template_credential_types(self, params: Optional[dict] = None): + Contract operation: api2.update-auth-key. """ - Retrieve Template Credential types. + auth_key_id = require_path_id(auth_key_id, 'auth_key_id') + return self.request.put(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + + def update_template(self, template_id: str, data=None): """ - return self.request.get("/template_credentials/types", params=params) + Edit a Template - def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): + Contract operation: api2.update-template. """ - Validate an OAuth Template Credential name. + template_id = require_path_id(template_id, 'template_id') + return self.request.put(f'/templates/{self._quote_path_segment(template_id)}', data=data) + + def update_template_credentials(self, identifier: str, data=None): """ - return self.request.post("/template_credentials/validateOauthOnCreate", data=data) + Edit a Template Credential - def create_template_credentials(self, data: Optional[dict] = None): + Contract operation: api2.update-template-credential. """ - Create a new Template Credential. + identifier = require_path_id(identifier, 'identifier') + return self.request.put(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) + + def create_upload(self, assembly, headers=None, body=None): """ - return self.request.post("/template_credentials", data=data) + Create a tus upload - def get_template_credentials(self, identifier: str, params: Optional[dict] = None): + Contract operation: tusd.create-upload. + Pass protocol headers using headers; binary downloads return bytes. """ - Retrieve a Template Credential. + return self.request.tus('tusd.create-upload', assembly, headers=headers, body=body) + + def delete_upload(self, upload_url, headers=None): """ - identifier = require_path_id(identifier, "identifier") + Terminate a tus upload - return self.request.get(f"/template_credentials/{self._quote_path_segment(identifier)}", params=params) + Contract operation: tusd.delete-upload. + Pass protocol headers using headers; binary downloads return bytes. + """ + return self.request.tus('tusd.delete-upload', upload_url, headers=headers, body=None) - def delete_template_credentials(self, identifier: str, data: Optional[dict] = None): + def download_upload(self, upload_url, headers=None): """ - Delete a Template Credential. + Download a tus upload + + Contract operation: tusd.download-upload. + Pass protocol headers using headers; binary downloads return bytes. """ - identifier = require_path_id(identifier, "identifier") + return self.request.tus('tusd.download-upload', upload_url, headers=headers, body=None) - return self.request.delete(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) + def get_upload_offset(self, upload_url, headers=None): + """ + Retrieve a tus upload offset - def update_template_credentials(self, identifier: str, data: Optional[dict] = None): + Contract operation: tusd.get-upload-offset. + Pass protocol headers using headers; binary downloads return bytes. """ - Edit a Template Credential. + return self.request.tus('tusd.get-upload-offset', upload_url, headers=headers, body=None) + + def tus_options(self, assembly, headers=None): """ - identifier = require_path_id(identifier, "identifier") + Discover tus capabilities - return self.request.put(f"/template_credentials/{self._quote_path_segment(identifier)}", data=data) + Contract operation: tusd.options. + Pass protocol headers using headers; binary downloads return bytes. + """ + return self.request.tus('tusd.options', assembly, headers=headers, body=None) + + def patch_upload(self, upload_url, headers=None, body=None): + """ + Upload tus file bytes + Contract operation: tusd.patch-upload. + Pass protocol headers using headers; binary downloads return bytes. + """ + return self.request.tus('tusd.patch-upload', upload_url, headers=headers, body=body) # - # - # This block is generated from Transloadit API2 contracts. If it looks wrong, - # please report the issue instead of editing this block by hand; the source fix - # belongs in the contract generator so all SDKs stay in sync. + # High-level upload/resume workflows are maintained by hand. def create_tus_assembly(self, file_count: int): """ @@ -401,121 +587,36 @@ def create_tus_assembly(self, file_count: int): return assembly def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): - """ - Resumes an interrupted TUS upload from the server-reported offset and waits for the Assembly to finish. - """ - stored_upload_url = upload_url - if not stored_upload_url: - raise RuntimeError("TUS resumeUpload needs input.storedUploadUrl") - - offset_headers = {} - offset_headers["Tus-Resumable"] = "1.0.0" - offset_response = requests.request( - "HEAD", - stored_upload_url, - data=b"", - headers=offset_headers, - timeout=request.TIMEOUT, - ) + """Resume from the reported offset, then poll the Assembly to completion.""" + offset_response = self.get_upload_offset(upload_url) if offset_response.status_code != 200: - raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}, expected 200") - resume_offset_header = offset_response.headers.get("Upload-Offset") - if not resume_offset_header: - raise RuntimeError("TUS offset did not return a Upload-Offset header") + raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}") try: - resume_offset = int(resume_offset_header) - except ValueError as error: - raise RuntimeError("TUS offset returned an invalid Upload-Offset header") from error - - upload_headers = {} - upload_headers["Tus-Resumable"] = "1.0.0" - upload_headers["Upload-Offset"] = str(resume_offset) - upload_headers["Content-Type"] = "application/offset+octet-stream" - upload_response = requests.request( - "PATCH", - stored_upload_url, - data=content[resume_offset:], - headers=upload_headers, - timeout=request.TIMEOUT, - ) - if upload_response.status_code != 204: - raise RuntimeError(f"TUS upload returned HTTP {upload_response.status_code}, expected 204") - try: - upload_offset = int(upload_response.headers.get("Upload-Offset", "")) - except ValueError as error: - raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if upload_offset != len(content): - raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - - completed_assembly = self.wait_for_assembly(assembly_ssl_url) - - return completed_assembly + offset = int(offset_response.headers.get("Upload-Offset", "")) + except ValueError: + raise RuntimeError("TUS offset is not an integer.") from None + if not 0 <= offset <= len(content): + raise RuntimeError("TUS offset is outside the supplied content.") + response = self.patch_upload(upload_url, headers={"Upload-Offset": str(offset)}, body=content[offset:]) + if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): + raise RuntimeError("TUS resume did not acknowledge the complete content.") + return self.wait_for_assembly(assembly_ssl_url) def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): - """ - Creates a TUS-ready Assembly, uploads one file with the TUS protocol, and waits for the Assembly to finish. - """ - created_assembly = self.create_tus_assembly(1) - - endpoint_url = created_assembly.data.get("tus_url") - if not endpoint_url: - raise RuntimeError("TUS singleUploadLifecycle needs input.endpointUrl") - - metadata_map = {} - if user_meta: - metadata_map.update({str(key): str(value) for key, value in user_meta.items()}) - metadata_map["assembly_url"] = str(created_assembly.data.get("assembly_ssl_url")) - metadata_map["fieldname"] = str(fieldname) - metadata_map["filename"] = str(filename) - - create_headers = {} - create_headers["Tus-Resumable"] = "1.0.0" - create_headers["Upload-Length"] = str(len(content)) - create_metadata_parts = [] - for key, value in metadata_map.items(): - encoded_value = base64.b64encode(str(value).encode("utf-8")).decode("ascii") - create_metadata_parts.append(f"{key} {encoded_value}") - create_headers["Upload-Metadata"] = ",".join(create_metadata_parts) - create_response = requests.request( - "POST", - endpoint_url, - data=b"", - headers=create_headers, - timeout=request.TIMEOUT, - ) - if create_response.status_code != 201: - raise RuntimeError(f"TUS create returned HTTP {create_response.status_code}, expected 201") - upload_url_location = create_response.headers.get("Location") - if not upload_url_location: - raise RuntimeError("TUS create did not return a Location header") - upload_url_text = urljoin(endpoint_url, upload_url_location) - - upload_headers = {} - upload_headers["Tus-Resumable"] = "1.0.0" - upload_headers["Upload-Offset"] = "0" - upload_headers["Content-Type"] = "application/offset+octet-stream" - upload_response = requests.request( - "PATCH", - upload_url_text, - data=content, - headers=upload_headers, - timeout=request.TIMEOUT, - ) - if upload_response.status_code != 204: - raise RuntimeError(f"TUS upload returned HTTP {upload_response.status_code}, expected 204") - try: - upload_offset = int(upload_response.headers.get("Upload-Offset", "")) - except ValueError as error: - raise RuntimeError("TUS upload returned an invalid Upload-Offset header") from error - if upload_offset != len(content): - raise RuntimeError(f"TUS upload offset {upload_offset}, expected {len(content)}") - - created_assembly_assembly_ssl_url = created_assembly.data.get("assembly_ssl_url") - if not created_assembly_assembly_ssl_url: - raise RuntimeError("uploadTusAssembly needs createdAssembly.assembly_ssl_url") - completed_assembly = self.wait_for_assembly(created_assembly_assembly_ssl_url) - - return completed_assembly, upload_url_text + """Create an Assembly, upload one file using TUS, and wait for completion.""" + assembly = self.create_tus_assembly(1) + metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} + metadata.update({"fieldname": fieldname, "filename": filename}) + encoded = ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") + for key, value in metadata.items()) + created = self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) + if created.status_code != 201: + raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") + response = self.patch_upload(created.upload_url, headers={"Upload-Offset": "0"}, body=content) + if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): + raise RuntimeError("TUS upload did not acknowledge the complete content.") + completed = self.wait_for_assembly(assembly.data["assembly_ssl_url"]) + return completed, created.upload_url def wait_for_assembly(self, assembly_url: str): """ @@ -539,7 +640,6 @@ def wait_for_assembly(self, assembly_url: str): sleep(1) - # def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: """ diff --git a/transloadit/endpoint_transport.py b/transloadit/endpoint_transport.py new file mode 100644 index 0000000..6c157cb --- /dev/null +++ b/transloadit/endpoint_transport.py @@ -0,0 +1,169 @@ +"""Shared wire preparation for OAuth, SSE and raw TUS endpoints.""" +import base64 +import copy +from ipaddress import ip_address +import re +from urllib.parse import parse_qs, unquote, urljoin, urlsplit + +from requests.structures import CaseInsensitiveDict + +from ._contract import CONTRACT +from .response import Response + + +def token_request(client, data): + data = copy.deepcopy(data or {}) + if not isinstance(data, dict): + raise ValueError("Token data must be a dictionary.") + selector = CONTRACT["token_auth"] + # Preserve the pre-2.0 draft's omitted-grant default. + grant = data.setdefault(selector["field"], "client_credentials") + try: + authentication = selector["values"][grant] + except (KeyError, TypeError): + raise ValueError("Unsupported token grant_type.") from None + url = client.service.rstrip("/") + "/token" + parsed = urlsplit(url) + try: + loopback = parsed.hostname == "localhost" or ip_address(parsed.hostname or "").is_loopback + except ValueError: + loopback = False + if parsed.username is not None or parsed.password is not None or not ( + parsed.scheme == "https" or (parsed.scheme == "http" and loopback) + ): + raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") + headers = {"Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded"} + if authentication == "basic": + if not client.auth_secret: + raise ValueError("Bearer token issuance requires an auth secret for this grant.") + credentials = base64.b64encode(f"{client.auth_key}:{client.auth_secret}".encode()).decode("ascii") + headers["Authorization"] = "Basic " + credentials + elif authentication != "none": + raise ValueError("Unsupported contract token authentication.") + return url, data, headers + + +def capability_url(client, url, kind): + """Validate a returned capability URL without signing or following redirects. + + Custom services are explicitly trusted only at their configured origin. + Production capabilities may additionally use the producer's regional hosts. + Persisted upload URLs are accepted so a later process can resume an upload. + """ + validate_raw_url(url) + try: + target, service = urlsplit(url), urlsplit(client.service) + target_port = target.port or (443 if target.scheme == "https" else 80) + service_port = service.port or (443 if service.scheme == "https" else 80) + except ValueError: + raise ValueError("Invalid capability URL.") from None + if target.username is not None or target.password is not None or "#" in url: + raise ValueError("Invalid capability URL.") + same_origin = (target.scheme, target.hostname, target_port) == (service.scheme, service.hostname, service_port) + host_pattern = CONTRACT["capability"]["publicHostPattern"] + production = service.hostname == "api2.transloadit.com" or re.fullmatch(host_pattern, service.hostname or "") + regional = production and target.scheme == "https" and target_port == 443 and re.fullmatch(host_pattern, target.hostname or "") + if target.scheme not in {"http", "https"} or not (same_origin or regional): + raise ValueError("Refusing an untrusted capability destination.") + path = target.path[:-1] if kind == "tus-collection" and target.path.endswith("/") else target.path + valid = matches_capability_path(path, kind) + if kind == "status-stream": + query = parse_qs(target.query, keep_blank_values=True) + ids = query.get(CONTRACT["capability"]["streamQuery"], []) + assembly_route = next(route for route in CONTRACT["capability"]["routes"] if route["kind"] == "assembly") + identity_pattern = assembly_route["parameters"][0]["pattern"] + valid = valid and set(query) == {CONTRACT["capability"]["streamQuery"]} and len(ids) == 1 and bool(re.fullmatch(identity_pattern, ids[0])) + else: + valid = valid and "?" not in url + if not valid: + raise ValueError("Capability URL does not match the requested operation.") + return url + + +def matches_capability_path(path, kind): + for route in CONTRACT["capability"]["routes"]: + if route["kind"] != kind: + continue + parts, template = path.split("/"), route["path"].split("/") + if len(parts) != len(template): + continue + valid = True + for part, expected in zip(parts, template): + if not expected.startswith("{"): + valid = valid and part == expected + continue + field = next(parameter for parameter in route["parameters"] if parameter["name"] == expected[1:-1]) + value = unquote(part) if field["percentDecode"] else part + valid = valid and len(value) >= field.get("minLength", 0) and len(value) <= field.get("maxLength", float("inf")) + if "pattern" in field: + valid = valid and re.fullmatch(field["pattern"], value) is not None + if valid: + return True + return False + + +def validate_raw_url(url): + # Validate before urljoin/urlsplit can erase dot segments or control bytes. + if not isinstance(url, str) or not url or any(c.isspace() or ord(c) < 32 or ord(c) == 127 for c in url) or "\\" in url or re.search(r"%(?![0-9a-fA-F]{2})", url): + raise ValueError("Invalid capability URL.") + path = re.sub(r"^[a-zA-Z][a-zA-Z0-9+.-]*://[^/?#]*", "", url).split("?", 1)[0].split("#", 1)[0] + for part in path.split("/"): + try: + decoded = unquote(part, errors="strict") + except UnicodeError: + raise ValueError("Invalid capability path encoding.") from None + if decoded in {".", ".."} or any(c.isspace() or ord(c) < 32 or ord(c) == 127 or c in "/\\?#" for c in decoded) or re.search(r"%[0-9a-fA-F]{2}", decoded): + raise ValueError("Invalid capability path segment.") + + +def tus_request(client, operation_id, location, headers, body): + spec = CONTRACT["protocols"][operation_id] + supplied = CaseInsensitiveDict(headers or {}) + if any(name.lower() in {"authorization", "proxy-authorization", "cookie", "host"} for name in supplied): + raise ValueError("Account credentials and Host overrides are not TUS headers.") + outgoing = CaseInsensitiveDict(spec["defaults"]) + outgoing.update(supplied) + if spec["destination"] == "tus-collection": + assembly = location.data if isinstance(location, Response) else location + if not isinstance(assembly, dict): + raise ValueError("Pass the Assembly response to a TUS collection operation.") + policy = CONTRACT["capability"] + url = capability_url(client, assembly.get(policy["collectionField"]), "tus-collection") + assembly_url = capability_url(client, assembly.get(policy["assemblyField"]), "assembly") + # A collection and its Assembly can live on different trusted uploaders. + b = urlsplit(assembly_url) + if assembly.get(policy["identityField"]) != b.path.rsplit("/", 1)[1]: + raise ValueError("Assembly URL does not match the Assembly identity.") + if spec["method"] == "POST": + encoded = base64.b64encode(assembly_url.encode()).decode("ascii") + name = policy["metadataName"] + metadata = outgoing.get(policy["metadataHeader"], "") + parts = [part.strip() for part in metadata.split(",") if part.strip()] + # The Assembly capability must come from this validated response. + for part in parts: + if part.split(" ", 1)[0] == name and part != f"{name} {encoded}": + raise ValueError("Upload-Metadata cannot override the Assembly URL.") + parts = [part for part in parts if part.split(" ", 1)[0] != name] + parts.append(f"{name} {encoded}") + outgoing[policy["metadataHeader"]] = ",".join(parts) + if body is not None: + outgoing.setdefault("Content-Type", "application/offset+octet-stream") + else: + url = capability_url(client, location, "tus-upload-resource") + return spec, url, dict(outgoing), body + + +def validate_upload_location(client, url, response): + """Resolve a successful creation's Location and reject foreign destinations.""" + if response.status_code != CONTRACT["capability"]["creationStatus"]: + return response + location = response.headers.get("Location") + if not location: + raise ValueError("TUS creation did not return a Location header.") + validate_raw_url(location) + absolute = capability_url(client, urljoin(url, location), "tus-upload-resource") + # HAProxy can forward creation to a different trusted uploader; its host is + # then returned in Location. Trust policy still rejects arbitrary origins. + # Leave wire headers intact. This convenience value is safe to persist/resume. + response.upload_url = absolute + return response diff --git a/transloadit/request.py b/transloadit/request.py index ca35236..5292efb 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -2,13 +2,16 @@ import hashlib import hmac import json +from contextlib import contextmanager from datetime import datetime, timedelta, timezone import requests from . import __version__ from .api_url import should_sign_api_url -from .response import as_response +from .endpoint_transport import capability_url, token_request, tus_request, validate_upload_location +from .response import Response, as_response +from .stream import EventParser, StreamError TIMEOUT = 60 @@ -30,6 +33,12 @@ class Request: def __init__(self, transloadit): self.transloadit = transloadit + def _headers(self, url): + headers = dict(self.HEADERS) + if getattr(self.transloadit, "bearer_token", None) and should_sign_api_url(url, self.transloadit.service): + headers["Authorization"] = "Bearer " + self.transloadit.bearer_token + return headers + @as_response def get(self, path, params=None): """ @@ -45,8 +54,9 @@ def get(self, path, params=None): return requests.get( url, params=self._to_request_payload(url, params), - headers=self.HEADERS, + headers=self._headers(url), timeout=TIMEOUT, + allow_redirects=False, ) @as_response @@ -74,12 +84,13 @@ def post(self, path, data=None, extra_data=None, files=None): url, data=data, files=files, - headers=self.HEADERS, + headers=self._headers(url), timeout=TIMEOUT, + allow_redirects=False, ) @as_response - def put(self, path, data=None): + def put(self, path, data=None, extra_data=None, files=None): """ Makes a HTTP PUT request. @@ -91,13 +102,23 @@ def put(self, path, data=None): """ url = self._get_full_url(path) data = self._to_request_payload(url, data) + if extra_data: + data.update(extra_data) return requests.put( url, data=data, - headers=self.HEADERS, + files=files, + headers=self._headers(url), timeout=TIMEOUT, + allow_redirects=False, ) + @as_response + def patch(self, path, data=None): + url = self._get_full_url(path) + return requests.patch(url, data=self._to_request_payload(url, data), + headers=self._headers(url), timeout=TIMEOUT, allow_redirects=False) + @as_response def delete(self, path, data=None): """ @@ -114,12 +135,15 @@ def delete(self, path, data=None): return requests.delete( url, data=data, - headers=self.HEADERS, + headers=self._headers(url), timeout=TIMEOUT, + allow_redirects=False, ) def _to_payload(self, data): data = copy.deepcopy(data or {}) + if getattr(self.transloadit, "bearer_token", None): + return {"params": json.dumps(data)} expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) if "auth" in data and not isinstance(data["auth"], dict): raise ValueError("auth must be a dictionary when provided.") @@ -148,3 +172,52 @@ def _get_full_url(self, url): return url else: return self.transloadit.service + url + + def public(self, method, path, params=None, data=None): + with requests.Session() as session: + session.trust_env = False # Do not borrow netrc credentials for unsigned endpoints. + raw = session.request(method, self._get_full_url(path), params=params, data=data, + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False) + return Response(raw) + + def issue_bearer_token(self, data=None): + url, data, headers = token_request(self.transloadit, data) + headers.update(self.HEADERS) + with requests.Session() as session: + session.trust_env = False + return Response(session.post(url, data=data, headers=headers, timeout=TIMEOUT, allow_redirects=False)) + + def tus(self, operation_id, location, headers=None, body=None): + spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) + headers.update(self.HEADERS) + with requests.Session() as session: + session.trust_env = False + raw = session.request(spec["method"], url, data=body, headers=headers, + timeout=TIMEOUT, allow_redirects=False) + response = Response(raw, data=raw.content) if spec["binary_response"] else Response(raw) + if spec["method"] == "POST": + validate_upload_location(self.transloadit, url, response) + return response + + @contextmanager + def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): + url = capability_url(self.transloadit, url, "status-stream") + parser = EventParser(max_event_size) + with requests.Session() as session: + session.trust_env = False + with session.get(url, headers={**self.HEADERS, "Accept": "text/event-stream"}, + timeout=(TIMEOUT, read_timeout), stream=True, allow_redirects=False) as response: + if response.status_code != 200: + raise StreamError(response.status_code) + if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": + raise StreamError(response.status_code, "Expected text/event-stream") + + def events(): + # read1 returns available bytes without waiting to fill a chunk. + while chunk := response.raw.read1(65536, decode_content=True): + for event in parser.feed(chunk): + yield event + if event.terminal: + return + + yield events() diff --git a/transloadit/stream.py b/transloadit/stream.py new file mode 100644 index 0000000..f1017d8 --- /dev/null +++ b/transloadit/stream.py @@ -0,0 +1,88 @@ +"""Incremental, bounded Server-Sent Event decoding shared by both transports.""" +import codecs +from dataclasses import dataclass +import json + +from ._contract import CONTRACT + + +class StreamError(RuntimeError): + def __init__(self, status_code, message="Assembly stream is unavailable"): + self.status_code = status_code + super().__init__(f"{message} (HTTP {status_code}).") + + +@dataclass(frozen=True) +class AssemblyEvent: + event: str + data: object + id: str = "" + retry: int | None = None + + @property + def terminal(self): + return any(item["name"] == self.event and item["terminal"] for item in CONTRACT["stream_events"]) + + +class EventParser: + def __init__(self, max_event_size=1048576): + if not isinstance(max_event_size, int) or max_event_size < 1: + raise ValueError("max_event_size must be positive.") + self.maximum = max_event_size + self.decoder = codecs.getincrementaldecoder("utf-8-sig")("replace") + self.line = [] + self.data = [] + self.event = "" + self.id = "" + self.retry = None + self.size = 0 + self.after_cr = False + + def feed(self, chunk): + for char in self.decoder.decode(chunk): + if self.after_cr and char == "\n": + self.after_cr = False + continue + self.after_cr = char == "\r" + self.size += len(char.encode("utf-8")) + if self.size > self.maximum: + raise ValueError("Assembly stream event exceeds max_event_size.") + if char in "\r\n": + line = "".join(self.line) + self.line.clear() + if not line: + event = self._dispatch() + self.size = 0 + if event is not None: + yield event + elif not line.startswith(":"): + field, _, value = line.partition(":") + if value.startswith(" "): + value = value[1:] + if field == "data": + self.data.append(value) + elif field == "event": + self.event = value + elif field == "id" and "\x00" not in value: + self.id = value + elif field == "retry" and value.isascii() and value.isdecimal(): + self.retry = int(value) + else: + self.line.append(char) + + def _dispatch(self): + event = None + if self.data: + text = "\n".join(self.data) + kind = self.event or "message" + known_messages = {item["name"] for item in CONTRACT["stream_events"] if item["kind"] == "message"} + if kind == "message" and text in known_messages: + kind = text + try: + data = json.loads(text) + except ValueError: + data = text + event = AssemblyEvent(kind, data, self.id, self.retry) + self.data.clear() + self.event = "" + return event From fda95a7203c7c44408467a770d903e8e981760e8 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 10 Oct 2026 23:22:58 +0200 Subject: [PATCH 57/64] Fix upload cancellation and transport configuration after review --- .gitattributes | 2 + CHANGELOG.md | 1 + README.md | 15 ++- contracts/api2-contract.json.gz | Bin 132 -> 1012247 bytes docs/source/index.rst | 11 ++ pyproject.toml | 1 + tests/test_contract_endpoints.py | 163 +++++++++++++++++++++++++++++- tests/test_upload_cleanup.py | 78 ++++++++++++++ transloadit/assembly.py | 2 + transloadit/async_assembly.py | 18 ++-- transloadit/async_client.py | 23 +++-- transloadit/async_request.py | 108 ++++++++++++++------ transloadit/client.py | 23 +++-- transloadit/endpoint_transport.py | 15 +++ transloadit/request.py | 18 ++-- transloadit/upload.py | 38 +++++++ 16 files changed, 449 insertions(+), 67 deletions(-) create mode 100644 tests/test_upload_cleanup.py diff --git a/.gitattributes b/.gitattributes index 758ba4b..abc19b0 100644 --- a/.gitattributes +++ b/.gitattributes @@ -42,6 +42,8 @@ *.woff2 filter=lfs diff=lfs merge=lfs -text *.xlsx filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text +# Keep the generation input available in ordinary clones and source archives. +/contracts/*.gz -filter -diff -merge -text /transloadit/client.py text eol=lf /transloadit/async_client.py text eol=lf /transloadit/_contract.py text eol=lf diff --git a/CHANGELOG.md b/CHANGELOG.md index 8f67d3e..74825c9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,7 @@ * Pinned the canonical API2 contract with producer revision and byte hash. Low-level methods and the coverage table regenerate deterministically; CI checks the committed bytes without API2 access. High-level Assembly, Template and upload helpers remain handwritten. * Added signed PATCH, multipart PUT Assembly replacement, optional bearer-token authentication and authorization-code/refresh-token issuance. SSE supports incremental events and context-managed cancellation/cleanup. Raw TUS preserves binary downloads and response headers, validates returned destinations and does not forward account credentials or follow redirects. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. +* Async cancellation drains active multipart reads and resumable workers, including repeated cancellation, before releasing caller-owned files. Isolated public, token, SSE and raw TUS transports preserve proxy/TLS configuration without borrowing session or netrc account credentials. High-level TUS helpers validate metadata and preserve Assembly creation errors. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. diff --git a/README.md b/README.md index 49212a0..752ce2f 100644 --- a/README.md +++ b/README.md @@ -76,6 +76,11 @@ asyncio.run(main()) The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded with `asyncio.to_thread()` so the event loop stays responsive. +Cancellation of a resumable upload waits for the tuspy upload batch, including +retries, to finish before releasing your files. Multipart cancellation waits for +any active file read. Timeout and shutdown cleanup can therefore exceed the +requested deadline; keep file context managers open around the awaited call. + If you do not use `async with`, call `await tl.aclose()` when you are done with the session. ## API endpoint coverage @@ -97,6 +102,12 @@ remain the default. To use a bearer token, pass authorization-code and refresh-token grants; omitted `grant_type` keeps the client-credentials default. Tokens are not refreshed automatically. +Public, token, SSE and raw TUS transports honor environment proxies. Sync calls also honor +`REQUESTS_CA_BUNDLE` / `CURL_CA_BUNDLE`; async transports reuse the DNS/TLS connector +of an injected aiohttp session. Public, token, SSE and raw TUS calls use isolated +sessions so injected cookies, default account auth and netrc credentials cannot +be forwarded accidentally. + SSE uses the returned Assembly `update_stream_url` and a context manager: ```python @@ -112,7 +123,9 @@ The stream stops on a terminal event; exiting the context, including cancellatio closes the connection. A terminal event or disconnect does **not** establish processing success: fetch `assembly_ssl_url` and inspect `ok`/`error`. HTTP errors raise `transloadit.stream.StreamError` with `status_code`; streams -do not reconnect or replay automatically. Read inactivity defaults to 120 seconds, +do not reconnect or replay automatically. EOF ends iteration even without a +terminal event, and transport failures retain requests/urllib3 or aiohttp exception +types. Read inactivity defaults to 120 seconds, and events are capped at 1 MiB; use `read_timeout` and `max_event_size` to adjust. For low-level resumable control, `tus_options(assembly)` and diff --git a/contracts/api2-contract.json.gz b/contracts/api2-contract.json.gz index 3ed6a4e8e576bd7148e14b9c64d9918c16c2bc7a..f8543d54b8d2eaf40e7ed15a5518857e8f645348 100644 GIT binary patch literal 1012247 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 Y6zVb%=8dgOBhA{$ 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 WF?T}f^J1!PT{&+It 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%0AVG?kqapax`NPO3zhEr z;(RztR?2oi4VK9s*fgdnxcR$*aPm(BL5T&0(1{PaVAQSmjDz|m>skZ8nl}4`1aq*= zD-0tiS0Ub3ey59KEPn!O(anetycF8;KZ5h5 z^DLz|&q0iJ;mOo-v0MVja{#>XOE>d96UIz zXAjSOmcA_ih$a|v3m%i=S`-O51v8W>Ybwc*9~ypQzMaN|#8%6`@r+#yw;8t)sD^sY zg}L;_rys5FVs%4quKD|{pObd}=JigToG^qTbT=}HO*^$Ud97_twALStjzFqqUri0L zw}`j0z)ry#Pu^H#P9uY`haOI3hErg8<4Vb3G=@yjsc*9UeQ zD*D)zaWjFoj2KTod||~)o?T_Uwr`s0;o+)s@V<;MOs8-e#vI>l7x}!rK~&CjZZ4s z9rZkX&KH;5$KLFrPwDf0FxT2gzD$1Ngf&Ng%0skykl$VzY1G;4X$)WoGs2$A^K&ll zrIg6${KWT07W*|5?yL1?v&2zzrfezc)B-XxcU^Kt*4M#s?S zImvGL1E6rPQ&LF8B!KM`173*p4?WzhRj>U*m-`DyLwfvO=WL>&EjBsQuR?|z)4Y@c zbDYSkx#2AozOS9P@7@>u*Q<9~6hFEPAG8X|r$k{@Dlw>$;|-u#&Tb}0xcodj3Fihi zkJdrc{Hx0im?&=Ws7OiyVL(p|)RQNFr`u0m@*gbmjRhZN&$jOq!BeMm_^15xKF>?~ z#ogHN))am$JFLaS&A!z9ifApr5}|pZ&DHVYoL{8WW+o9vwE>Z%e-N;MfM&bkzJZFL zCdM(z!}+iJDg7$kju^y(D8=j%H_LMH1`dHc($3K;|MDm2<{k_!b(rQ3hs8;Z%a;r# zND#P73b1wQz36p-wNA#5ArHgGmLKnQ*P`N3e4Osl&BmV8WX-AC;VC=jYUS=8ZX|Y! zj8{J$W*7d6xa%E%fz>wv4Q>^mM&2uK1alp9}Byy7T7k4?Q(&vfUe(W9jtT)kh$FrK1;e!&fYAxzSCTV&lL`D}U2Tv*oU(_}^-s zGl==K6bTm`sOL==?BADjFW#DzYn&}-%Umy-_8K#*sj+d}H!Gd3DFwf-T)4B6t+=w% z&E6)}I(1zw8svhfk|R6Zs<(x+ubZw~{4#(M-Kx^=Use^J!0*m+vyJB16Xby5yLjrJzPBhXq z8syQjbLRLRw>cLIV$q}PE)5)**Ql7(rjH;80Q;dv^8BW&Yb%56D&Fy6$Wxa%ib%@? zydAN4n-oS1-EmE-omnY8pi|`js&f>mz(;h>TDS%OsaG^XZR^>u)!FIXA&P#fH(z?4 zGLGA6$B|7@ee5sxXaw<*S;yn2@cNH7ht3#1)dKMf5SUq4ZxW&aw9U`JFLNpbUoF&H zSM+u(kN`x8GsvK^U)j*#EsUV1bf(SX$Y#nt>oK>C|MrM)g?XjQ0~I0VPJcszBHRl@ z^}Fu$YO9=|WwRLecov0kB|LEWfBA`zF@RqwsPiCZ636I8E@64KsSZ`{8yVl90pN+L zE)2*YzC?=1<8P%DdEXRKyT>c(Ab?%!*T4~?bKb8C8v;_o9pe0f<#yxc zq8Y@zP5&m(z)A#_H6LU1FCcHJT$w!Z49^0G&v}zlxkPwB9(rc~{y8eDF_jx&x#B** z=L^rEV0eTt$vnOrM$>81S&MGBVV>;lg=vLg+L2@vv{IoeKZv35&})qZNHCQOj2oxj zVv2nOT{J{KARWJRA`GZ_!@tv5O%>GI$B4(X*YkGOB$`10cS_@26 z-6$}~*0AwlFsrn zYbzzgN*zGp%oT-L>TBtB_gnSxfUcs*jGqlHr1=qj4uK(!##RGC-&tMeaLQ2nKOL9l zW!|z7ZjYcpz<8o#H;jBj^~kyt@x}F{TknB)Os@^9MMwIfLzy;WjmrkhQN~Ai;MuA% zpRR!0m)*7#)gGLtlvd<|hg>0$lFbEMbb`=BHci_I0RE0(yQKXA5HKkWIKMO4=~RCz zeLCq#;s0j_i&Y#at#hk>%C)oaXXo;Vm~;-F)Bi~+QjAa`_%vyO?jW|rsSBpM`&WpX z6Mj6fg!uj;9;JuQR9P(z=Jee&6QGm`gtVEDTjeZ*xk9a3p7;Ql04v0UjTkP`5u!BW zEmynB!jQTd`DLLz7Kbh$tp9b`CP{ITCsdJ{Fr2zhAZj_mA%(;L2x3)Txjj2g8P;Ha zuHhOsRe^$Lxhf7U)ApLF{aK(kv`x3_oZKt1@%?BbQ-kiOssU*YN#XnWv?B+u@cV4# zP&h|(i=ZMKC7K%msoJogPDhLsW3Ulr*!*6=lq+;(WDcgtETa$xGcX+Uugk-;v=vEc ze(?W1r^Ss0D1XKdxY<>aUx$1w9&aw3=@0nH=c%*cjp{m}#knB9P{)fyA=;Y}JY5i| zWLxfG5q{G2Be!i7$SPeG@16St z+9!>76Xy=-1vL(bwv{{CEERY9Tkq~fF#(uN-xawI|a8KIkks`ozcE67&nB{I!^44tqhw`xU%3*Lt&Y4Ue$6FV#+r`^H zRUT(ob(UtYqILj_wH`%&5{^?^DA0iZ8Y)B#Zr|bE9)v?-qKV&bKT-2_=phat^IPR* zvT&76hv!!qon2(IvVtRTTz+QNY9o1>HSSF@{^$!GUY=TfGQa5|6qYv`2S z0xWxDC)AY!nNpq$&VaaEK>N)y7Y&zKq|sN#Fse>=XkZIP*-A<}dfH3giQ;bR&3kPk z;OUq+!ohxWLf(Uw2tOaT2xijB=DKmdpd zMbC-L?h4{M8){vOqzDzVDGk^N?iFRlecW-2Z0D0zU+0A#M2*vEP7K=0&T)ry zgtwOMf;M|8^qz(2+T4i=6zmR&{ zCEFa0Vyp8Gr>lbO zf{9=kwEAzt1C6X+c?XyB=I81A%yk#%`^{a9Ah4VYlvcQi z5D6zLjpY@c!cJ$Md)i#`%nHu%h{9XMBNeSP!IPKit$j=t33X+OH0n4{xxptLVhTXP zD(J(0R;6@Pe|zec2y~cC71VMUQ2;E!{$>^I7D|f-yTl4&4-rZoY>@mbU~Yg(f~rvC zQGhXIep-|Q++_2>DYT?QqAAEPZp*}Y-_0s3!2ew7+%j`paNlvXqzno4)F#rwC=t70 zeLdKr-~m%?MWz1Ks>Am3RQr1CvutzND7kQPoG4%Vj z6LgzgCr0r{lyr2P;D(EqKehIT9CGQfrBi^~lI5~&$z^kvOEW1pt31nwSi80@mz?-3 z?hLA432ez+MRR#HDw~q5{T^Yn)zY2lFg%xT$;OSg|3<8H3FdN^){^;)E~Q@t2gAJ0 zB)r9B?&0!9GCg-xHEf`3TQhuXVrkcjU3!CR0(%^OKg$ji;}&6y6ZCvKf>M(h@_%^NNqWOSAWt{ZC7t2Wylusf?! zV%TKc%^$^P92a8HXdGrOQF0r1>mgPu7`Aztd&LFT^MWEy+^mG!)d)TfC#%+L$Tkgo zt@Rt%+Ire7!N9(3tF=NcL7+M<$=+oEze z0zRsH5uv}Q1A8uK)l24VtFqm5)qr~e$Qrh+>D9om!p)mNvya?*Rn*ilDyrbw%yLcu z=uqJO`~pi!G~wzgZVe@b-(KCw(rsIM7&(%StRph;a7I@oxRGrHE`r1$ES|!+teU-j zS-+9b;YIq$FC9O(T*dfbdl{(X36OeY`xMKSp$wOJg3JhPs;T<~^Il7&rsC0%-g{@u zSV;T4G6>!^Ag2{{RdPnS44|;+#sp$rL`Ym~!cOC}BasvXSo;>?m~djYU0Wipnyb#( z4LEiE`tf#c^r>g~gGp|Zo=h7yd5UKhTiVm{A!!Ac9S!8{aTo#F_f>5<5d~!wIyv|p z@hiY6;nGxMhZ;y+^#RQV>{H_ddGn(B$a>Cmsx)QZ*7(Oo`@5@-O_$!eSDw7Q+{oH2G^9mr~GokV=b2{GPi`6LKqe>ZUH0h zKOLcZu|bTv;kqAAF=;P*X1yNxJb3P8Dj2(>H=qa|mwfL{KQt=n5LM>@M;`H;TA%FeQwnY7mMz zqz=PEM*&sYue4lMUPE1FDxc#$zS$&FU*(3^`i_bNZ45|(hHL<*(HRiH5V9L3Q}PYW zAX`Cz@ODLhC?Or(g`NnsIOK}r<4lt)_t7KQQBWp555zG4^5pQ+NCar@+lG2^#DZ^F zCdGj5#XFf{hWq41aL)X}CPCEd6S z;uot_ZQ|fK&9V_vu+hFNUDHR%C+=*w_p7VSSM+-J?;11E`;wBaY%~BY120=4pE%$9 zm*G_3$n9alV)KLdSWuxqNRF4%9{P-=k%jyb)|UET0e2#W`gHIhtBp@&2R;nCC+Kmx z0)>gBRkg9USjZ^~eTkaE(|A>pA5ae!beO>wAz+*vC1MIAs=E1+O( zfP)p|o+=>_a$1fFf&J#$&Ryc8E@|3PN3OXM(EemJ{+#|a>Yro_PSG!!zXy<&c&Jh% z$;0-YDlKK&!|f`S3JC!vehkKg6!`^1>Rq*)2k2#?Q*+!M<0#$V``dtTTlM#*1MUBU#;v?FmZ|=X2QKP z4LBfp`^2n$-^+7r=U-Uak9T6Wdwu3IXWQIfe>k3e_T9Nc z^J$;E;f|uyn58Y5x$Rkf(h_W+gTZRL`fdE(c5n(RWf?Q(=0j<>ev@t2wtVZln77S5hy32&jrvhfvf0UMuvz&i*Tkd zchmK4b7>x37wD(QjXFi!6P3RFh;49ofG{t$|Mik zOZDua&lIVI2U`r%kSWe+uvOJCsPUpCb$3?7zHx|MLk{H)z?R8+pv>@4u}0aWkyLmu zJk%C=FT#1qUWK2olwujo$l*1AFl;r9qGpRP13*&o^?iw|n}@3#wHN`0e{HrvDU?>d z1jah7TUc4Pb-8KA=}NIj(|>#X=vAB28!V_T4R}O~5n>dZ27tk?`24K;r>HJ#5?#gd z|1YT*yj^-1otOPzCG}7t3op5Fh6Tm6M6UkIq$%E^?EnJG4Sq&Yhx_x)^L>av>KsFr z)JgbBf1waJtB)|^*ifWkL|irOUryY)m9 zj!Z5!5yM$R9{1ln>Awn7QKEL5EkH#W)Odo1(`6XG#EPVi8kwLtHBv-_;K@j>kcVuj zXF}7c)aapWfc~zeQ+)|IH?!!e&pB`wW!s{lhef9d6mYoj%R|p zp8rJr|F94{`EM42#drfnwMGxxFQOgD^^z4Wlb0MSg{pMIt{Jo_O&9O)Wh5L|Y}S>} zqs#%yEqc^_cTgdvm6UA53-PkBS96OsGD|cMZEUFDHsaVla9;aeNyk?MIR3^^UId0R z+w--4-9t9%CD27w!1_9ac{M%Wbsy-jurf4aD!Ts$L*mg@84i1OpoefVLi;JrHWwt5 zwJN3RA^~m<_R{UY_-Z4fz~#(U<)3JhE>z6CLJ4Hj{wk!m#vXeYLj%cxi~m(gm%=l_ zA^EPPYxFu)NF8w@iY>qk{u>YBw2aj;Blj|8NMe`JFFOlL04{g(!85@i0>QMW6eFHM zRPC%^EyB4?^sMQO>m*uLnei@F{4=tm0$`WttmsHZBMp`kVL-Tq7_dZmI$T#SB@j54 z@C058mbW?Syfx}RpcK^chwec5t(+*8`y>HOE=69Lz$>3UYyq7|mE7lV3Q`_f9W?t} z8PHnd!9T%56|EI0Z8Hx`<*>xGhMH40=k~B%^q$-)BjW%ulFr^BytP!;TL zm;nMsAH(->HR^h^c(_M)6)*3(uVEOA4K*wwGJw(!{~L}pSj)jRIYhMeeUy!UpMV4F zwNY(d`}rF;*u1sAKE1C#e)ju6n|sR|JM`v#na$Q}_`Q-zS3HsLa31>jqgyCdvtm`G z#lvWs8np=5dZ4qB6kd9KXz~7zl$b)D7i%B^-jP|rumz7QEs<{CQ=Ug7I%;XVW75wI z|4RH2@=h&g)pV^59F2|qitYRwp7~Sen$>*|>e@{z6`im*9Ig>mbu!dYy`8e9&B*~DazWx zMOA&PYCr7H8rptqZt5aGqy4d9O>Q|YR@sbwU^A+UTJEas*r0FA_I0A=Ke70nEstAXfeRkpCM zEewM074ia=IzrehzQ4p&vlD7sYrfLjP60xH(8P{#$FKjPo(X@=F2j3w!{s zcNg=iZTdlM(x%O4oArHB4Ej4t(LCf=xU_WmqSl4hk$>(&h*I+|NcwywL}Wqh6LoRu z7P(+qW1acFFx%OVsrdEjulOLB+`f3i!j)~ti7Rg-wgNAvpj2c)9cfm_*c~mhU(K2< zRxxAKY%DC%nl}GF2|TB9XfsgllBa69ny>5H?ov>QwtGA8}~6P zKoWer;cmUvkkeIl1ONerhgb*yYQK(8kgogDbBa4>efTMO<)fKKz1p-?-zn$KOjrd) z;#=PSl(AuzLw=rn(WcwHvKb4=SNcJmTq0o9>Qt%Xd=6O^Q~vsj)#KmC>vXWlFxh*+ zK?04BIYMB$tM@eZ6!3G-@gsU`RVHD&D3U)MH?s76zJFz~&1ubf>VhTXF{I?0(ALQQ z#Xhv2Y1ZPb7K_(N&Z0_DwHOXD^!uz6%ka*%GYl|mDFwc+eOiEObQL~Haljt>-Z;Ze z!{^?Q(iA8tswV-6-X;6{nC`E)7L*xBuWp?6ir*Q0<#Lxl<=E5L#D&;9tPAJhNaF># zWcdytgmiatvVjf}ag!(|&A5~R2%zp$SdLp8gCWiF0nJ%;R-n$S)h&glu@#&qvi9`be^N8aKy7k|6*7p-f0_hAP3}RL*Zo>}^lgDWDWb4Ux8-Abc24>8 zFip8^P0zsz%5=x_Q?cRf&#iC)o^kwVp}cHU55DE5qW_Vn1Lwo0@g$QJP7WH*Jm%csaG4>MPA1_42l&DV-XX4r?COnwWCcdf8P^PeaCpQwF z;Sgy~O{x5vWGm&Gi3iPiR&=D5hc;vNOZNZDc z;|J&R^MIn$kTqn)Lvx5oe9DBq`gxBfm=>~qs|~=ZmInm1lMi9dw{q1Tb)6@oX2leCS5k?by&s^z664KG z5L75THBf`ksWlYSi5QYtP`$&>ce(n!^FqienbN(hN?X|%rwV2!0RtN$)MEQO)YU?Y zmnzvC*4DV-`y0Dg1^v)nyn*;iN%b!<*1OhKbt0JezgCc1+f!-_)AH6BJoo(PN$k<-b(YFb=V896+C3S9;5EqHI#Be8p4-ZZw z8IcWLcM#9I#u*jr?A-TrkN@i;DCR|yY4lgXAK&sWjsSWTMz7D8BR4b_$=$FL!sCSB z(*jefDqMfuSR|qhex?n2$YlLRkjyuoP%MWRjSedOF+Z@{uf>t_V+v}iMRAxoWFL&A z!>k?X2U_q42##Zir|TDpmqxD^y6=sm^+7*BqQ0S$LI=rTBuTjWcy1SeUov0*rTMN@ z(S%A?I|EV>2RLpAD=|}6Tn*9#R%7GF`8bAtysL0`sR#KjW$$V1w~CK1p|aNNab>?0 zuhi8nayNaHa3^=k0+35)xY*?O9+UnuJywNWE5MuGpSizTQm03*L=ax)Kn73wlPXa@ ziU~M=o#QqSWM)eN%e@I1vma+9^3IIEqTnyYS^!1`hhZUqXEQ)t-P1iu8W4Q1$NQCL zDG29?Ff`GCNTULKJ(WHj zWKIH`^vQ;8ZQ~w(0@j!l_BZZh)FP+`Z4}xz`P++fQNcxwB15i_-}#@lU&7GdoADbB zw&H=)(5NxEJqaEl1S+5PQ(2!}@gHB~-O)rJ+Wau{wo9|PW%`4v7&u;lz+ywxb||&I zo!!?dywqs`&Q*Jn3sNvr3D%rH;|xd|L#+c?5D46#W`28#+HVk?%pb%HAB@z(TQy;MK!UFE(moVMw)3^7p=nSY<#kH_m8=>gLWzVpvbFgO&6 zLI<3PNHXHCpwc>snPIqT)>YnYJwGa^o54=A0C6s)w1FJKcoMuG>*QoCRIc_eBqbiI z%uoWz{x9hA<=-N^1q$MEA$HO47}2dzEz!GYGzd%I+$qqy?ccZ)0&~>=#7>WLBoh#_ zjJR2nZ_YgOcz;HO&MYm(-XFqalIMRu3_{|+?bXQ)zoi*)j&%8g(R{g4Y+lMcyKu}c z0p9C3lpWk1GdgJF8zUO_>si9m&S|TwjkBrVmYF(yKJROa;HJJ%)<)cei41G6im88t zr#l{Q=EYqH+k+q4$=I)oFL2>PwPsVvIP9Lp27PANa@>%QA-P2GD7;$<8g_bq~^E`zUu$g1;sta-Jb#5)#Uk-WCF5( zM@k^*DJPp3XNpxeLFn(j?FRrMt7mc}A^QM;ZDv^t9s!SEL-4$7dnT1L(_e_D@c^M` zdh9ZC%o0=ZL1L-CG5;Qy&S?W}$-I_(%Tg=XM7y^>z2?7*9v)FTzpZ3~QqPWL6FI~l z@{d~Ut@0D@+Bc;EUu7($J zg9jc>2YIr)as~Jh7Fy^sqdPOl*WTyz62?dD=xFrYx}pE|{N~&Jx$*MyMvtbmYj(93 zZ}+=ZT^xFdNYF$JDX;lx5nZ1Q_Tw<#FIZYp`_;PhlIE*xMeEhOpyAzndh}4=zEjWF zkiTL&`B7e3Iii?x>%)suNe!Q6lrRSXmwIkpV!XEm!t}jL315+$_80qex=vte5) zERTDyMX%THCs3jX4j#md_})5`=RLLAqBvz%hd9r$xNi5%Y0E_}s+;agQ-@G%(Djj&_>x-G2n zeOs7T9in^1>7wZZvU%l3XT|23wuUyn&z~RLT0>_mE}FQF?_99qg3WSrO&q$7%x(^v zB=6e_b-&F|X}wnFUcF`IY+?PZ>~gL)jY`|DXUk@=)%ovkr%8dv!ctb?ug95yKU{Ew z+X=>_fMSt!`(7xF4bNx(8jrMMXXlybbg5hQwHQrevAFqfB5x?FBS=gl2cwXq#=&qB z-Ea&dw0?&DjKMPrUtpWKwWl>5?8X|IbGaiFD!{yM#@;br7~DX(bSg`Y!{2{MK;86s zliYKT9nZvX8FF!}ehP%u^NP-+n?1+2%E|6TPntvW>s1l1uXp6F%=i_DfhmYw5+9t< zJ~?J`zLM?BtACiaI&;v5(9HvPPPFYV!*$H`MqRJac5Tz*ea=@?blEBzdbX_757Hz+i{xS-3^5RR+BdTd)vnSnt{Z;*K`c;_p}9O?O)TDcJ05WEs`Gpnzqb){xfZ% zieg%c)`FpG-)e0C-E_4k*ST0FS+eiMWKOKo_9L_PLPz^Fy-r)_5Rb(HM7ORy7*7NZCih`=WSynWs% z(z+t@q`NE~UcPg3>lg7MU#bP5#}cF;1F=RhzbCXo9T^M+c#r47l$PlR^AWKJaWR4K zMGA3VYr4K44k^XIAS4PX(1a~by0h)z_yJdvEyZgF}AZLY;Lw->{KNC#av z&N3<31>bIVV=1m6)TwK!wWWm=&ZI=@!TgSFDY_u-)o_p<$03%-S>xF9f zEJva|HbdwVYlHV&V|lyWK0-8fOgQRE9|N*oZsIG1HImA-Mr|riFW#*EB9BIQ)Klu} zP4b6Y-*EPp=|A1Va>j*-?`|PVu9pr|xtqLA&qQw#s3&;@)0`o>6FmJ^G(z&N)b8Z@ zNkmQ+;;_$s!HUiv`JQ8c&OYcO?Fs5 z?kta*TM4FbxBnb*!>Acy1~9+WH^un4_i(Sso&BSef|9S_tR*|5&y&2E@sX;69=cPdF~ z_|(-L*Be-uI4dXk*FJmn+&D05^^cG52p1l&NC4A~QkVo~m7j(IVI?8urf0aqJZWF5 zfQu%5Ff~Si-2v?}ZaYt6UzMU}=71-bs?wA};Vc}>lZ#n06&Ydh`}{dqSMRaX zeWmy0f;sj!F^o?b5vN~V@Cn8c{5tawepETsCQp)2t~l_Z!lBUd;H=NbDfw=0po}1Y zeDNJ^P6La80~zScLx3s%3qcU*ps8Cf!!8%Rg*2_{!)FPwTIfCTQ$*<&MjU~Ed7lOe z#Y#-$oTv=q?#6a#dhuS!Z6X=t`3}Q!_b}ly_-`1D8zn$6VvcqQ2dd}?Qh*e97mZ~E zMZpg8TqUxc-+b$^#q44~Qpy}swg27u1mj|B7qNN-B$R)ISdmzL&&ctTzJdU^UprWz%!l#*QkkkDiJJ48yY@qkrU zQR3qC#x&d}ij3|2ommFt<;Ia|ms|AC1xtxh$$IbZB@|BP0H@q0 z{f!-*-JeDYD9~Xw3~Y_=eBH!E`Md;w`XUTXL4fg~vbMr59lygU|K(nRd)3_XB6$z^ zblfL9(4Ew{alCN>ol)a-c$2h#N(p0lIT$e2Se(lP;#1t@c4JQZ?e*}#d{4)YFLUUc z7_RcthT+q6>kbdMYZ8eH$Y|0i;5n9!W-v9!jmQ-K*)FO;XwVvHC8f=>3R@MOZ8 zS}%O3jc9)?bNjED(@HhLx-20zhzsRyhy&*)gsjTGd?{_*|4}`)-n??qE3`74x(}R! zgLhkBDpH6rs60@h1mf{w#01ox@)K5kPP=8W=>YkA5*TOhZmEUh2TC9LR4~4AB6aU3y zNw27-E+rUM4^pWbtGN0q-Voa9ZJvKAope@cMjWYF)n)enPSJov{v$;rzlRE@Vov6Y zk4Gb3z(q#IRY~GOBDEc;+63%x zg8ddddFnRlsv2cX)w_nnze)Ep%q-@DVHFZ50H0cDpn*Eai<)(U==#JXZ7nMlQl{5X zOsP~G8hF${W=9x+1*Ch%_0UAcj_ktGM%2<%F^dIvq{Y~? z$AK$RU{WL3w5X#RbckOJjItd1c!EDmr$0mU+be@oCX^TPg>pasu}{GFf$3a=O6QS@7qy8V%6#3IB? z`KL*IZ+a1Rj=IAfe%X(-Xa`7>vM4(FT_g?^Wcv-$8v{yQiC2**fTaSL$nkfFSg66%*O4a#sdwK8!6{_omdO&8WtJayvq<z#P^Sjtd57<|33^Wbd8L*-)mciU=9?u?$6VYosbJy(bwYX_4Nfq zglqMkUjRM&y5Tn|l!Cs2w=u;aTG;!@y#xwD9cXl$*gKuFF@p8Kd4>KGs5pmVk;pMY z75gRb+!ahT<*j05Y~@$m`C2eRH021^YO7XDi9UPM#p~pGJhUancYiK7*`l=_D{plD zMm;GS^CA`ftUgPnTiJupPcHjAWeY3)J7p7hw-(#b&U-y_*;!gDkCxRK3?A!UQ7Avn z~nLC6cI3?WKDqb?U=)jwHo!S#WOnT~S?UHxS*Xr;+d@w0z9lu1lM$SbfjK zm4pmqWdq<3cF#)`;88Qt?Ser$l$S2#US7Co`C~1#%S14f%MA0v_A)Ha!1HY&dlIZN ztBfafCkif z>SQ!GZ|Rk#n7lTL1+AvWp$gUdqICEiC)~9|Dpe~9Xz=Y{Tt9QZn9&rG z#e4S(uJpPsJGbaRHGR7^t$&BB4i+z$n{>_sFw$tMeBxb6g`o9$KA2b-rhl^|+`WqC z6uj9C9Qg@6Upr5kjC_V&whgm^vtf>a5%xDv-(WF*_<7$2TL|e~AD<9#mE35?9U$1_ zJumI551qI9Z4Y8W4DH-6LJ9okp^uC}BO@jWn0?bz|wPQ7pd$673z8n%E*)5f!j)XcGYV-jetIjH^ zhspBB>gF7TokDcvXRriMIJ#jw6A8Ls0C|);f|ifhcY0#$R*=)sQob^%=Q+Ms-oWd3 zSP2I$B;l;TX7a>okBIXW5V9okiRQuFUy#@cuSsyJ$afje^`l22!VDY?g?_n4u8W%` znLilygx(}nve1f64+|{?v_J(8Zat=WyVGvW{5g}EBPh=fVPY#eoK8=&{SwH9-WwDM zS8>RH@vDQF%I1BUc@=F#TMjdav)d(>fK7)U?tiu=@E)+wyq7n2y1$c#+w)hK%a-Iv zA>U#oI388b90sMc^vHE!_&$ZJ74$>JUYJv^IsjRYU8&;AhllK{B;CKYNVa7pDdjV8{fyDb3FlL!_OF$AJwI7Ip zX^7qtA`iIdEv3%VSf_H^S%}0A4isB|2-LDvII@=kiWLY&PD;*n?eP-RiOM@B!VScVzhWtcWSSXkDD3c zEk{eq#m@Z`>kKO|1xU_?JLI)}jdLZkgfVb)Trkg)4D0I-CGairpc1B$QPh~dr+tNY z&6yBApycW8p@7cOh!<5bj6)B->fY?*%yQ9FgY+6>th#OBD#E2q1uy)`1A(D$bKy94 z0Jy+_(~ll0$d2{vT#q0jf#6fX?SlG#Jy4dlEIbsx(2QzWOv77d(Wa`LKx)`+C0Jp} z(MpftHAp#D60wiEdep5#2{K3JHdsG3oE38a_jjAD5e0=A1tcE{PL+j>Obni}>|6bO zU-tmqJQ9>O3tg6I3o%QYLv8kKp88f_|9JdLPrdD51dPF{?cWZaJgFM34tZmG`SMB> z2Uw&?Hd6qkwMQ(o${}^abbu%h%YXVBr8aC0Ue$9p*0cd*(X~|@Y}fA6Ja=!sX3f2k zT*~g{Rycb=$8&94BN%P7Rwo>}GVf=xoszghAjMgVC~LeT9O;X2@?wt7 zA<>rk;_^3Y4H6ID8z+VuSZ!5i#+G!RJo*_6?Yn#gq&(vR>!UMm8SXJr5s>jKovYDf zg}_6?bkkrrVLVKG3AONcTQ6v34~XbF`e4Xbum*Ersi$RnD0&54N;8Y9Q9{*M5wdy( zf&Tgf`oRkE2u}M68qr8|>zXGS-QVzHeDAaF;XK&U?Biyz*;j$xo_F&lTaR>p>=sk= zotBeWl!cCVcilXHH58dx<-FMeVo}~9;RO;3x~BTd?t7U!%7GK)J9qIy$n|c=Yo?L9 z>w)KeK(;u#^j`CTdajD|&`oCr%Kvs;f&7p(7?UmD%}K0Z3xzgBcQU&4cD3mrLJ?DT zJQaK-ezk?H^~iA$E@%xCpFMFcjn6)S#qyJ%_$r3Ax`E#vaQ zDeb2_X!lTcZTkWMdAp7W!U%GE8CD^yOIanGJ%#xiVbCs5gcG!{#2P$5hZztlWfP#U z^DMLII!YJC00H>}>!(Z9x7sx|Bw6x)n2f2HTEr=AX~Hu5WLM>0{U5sCAxg6-z|xHj z+qUtCZQHhO+qP{R8MbXR!?u;-h?iB}wO)61_u!tv9o*?%YoBlLPoMW=Aj#N%gc)bp z-Pyo>`sQ};Na4s;=k3qlAQSMz4DFT|T9{3)FM?D8c-45#F^Q|VZ%|K}23QJxsxnur z2ZB~j99Aqfwg6ems;sYu-gW~{OW39zx89N^xZD3;irBROhigMwF#-RiS8dhAAGl<8_0Q+(0R}LPPOSm zo^$#>aW~m#`d$`aYgbog-rKD@ zF63U)9Vd~#jfy$Z2k>5-#%V0%fn)|!1vyq;=CX>@`65kQq+)5VQl<>!k_ZfcR05orf+cFmed z)v+aDE}_fPB&I(jr3-X8N0d%BpEdm=|MT6r(Uj9xzDbVa#1u+Pk`sQ zovRw;RjntQN)q#0m5TI?fWwU$Red4ms8vP6vy??D7=AF2(PJS^JMkfjwIM%!hAzR7 zV_`bQ^c)aRqlNx@X}mM(4wf&`SxSBbGGN4tT#BLM#t)YSR;XH5m zr(aWIis*6QeF}~tbnCV4!u0rg1G#(oja~os8M}Rkz-zk&EyQSsXcQE8?7jSm+*!AT z0xBpeE2OUm7yT9IRF$!9WEUwFwu~7=ph15|pUY3~qzNQUt3bn-A1DHOsifm5q|pKL zn5j@6WAN~Ad8F9on~(A=b-m9!FAB+x%&-ww7m~3PpdnV-EKoQvL@=b`5XPJe6_5+m z6W~k%n~X|S7GHr-Y~$Rck+8#=K=X)_pxFFrnvh3fnvtYkmUHP`C2mn!TuXnCPRHAC zS7<133_7slbxYF@jNWg4sxs@9H^&uTGB-n%;3?D&xaGceJxcj(@i-wq(^7` zTV5RQa404}N=PRgn{<9yQdVg$@Sz%!?D&zMIh{(fFBJ+JTU6nY)8;6Bg*~7(ZpP`8 z9G=kW?~0MM&=L@hk0@bU7x`>6J3a`p5x!M@!qhJZ9L1oW`@4PbNJ zVnj8~;1fAPt^_mu-YrN+J2JP;{VlLw@$%|;yB27ha&2Z1(Vc8w`IML4Hc{p=uy@p>7UfeQ*Ve_>E=ic1`b*{63BlM|HO|$lpl@j)& zH3w%$ZoS2{`JVXKf`sjIrAEC;&)&2L;OyDcq?$c?dAsqvxYpXD`DON;z2Z+@?H>f` zP2j4ylsH*q(Nr`O)rAyI&FCrEE;r z%h)$F$xi*#s>YYDzdc#C6Xslk8M|^dxdyuA7q$PVeezaiw8*;X9VNCcY+3Ns(rskm zzR|;uXR7i{M!6@v?SU%wdy>8F<1 z|5d#dEIjI20#9FML@&WCbDF{uSt$%ebz?;3LoO)vs{-_nl}!REL;qDR_kqL*_<6sg zw+gNfon^%oLLnm8i6B8f@=?ZW=o~di+?FX%hLztHibn-iPZdS`C{rB5jE6;(E;fXMKMLOQZmX?W#bT*o; zDP!1MmS^bB8R2ko-W`sF9nnD5L@M>64@57?s0q-8i%u0;`2ibXZIH`%+KWE_-NNhG zxfTSofi?FtXwSRty>t+6fqj8bY+QT;)g!hnj8ZhH*DLF2vc!9FJH=iZT54yks^Olm z72Vmk3ZpB;UDQKVz>+Qo`>PJE!ei} zoLh^-kq5g~ar<0Uiw9n7)0JCGAyTYo)+MRk`r-Dc3F6uhb3?A2*Fw6Sx&9;WkPAfL zjkjyb8o`Dtx0V^xBahlUZVmmb{?zRquY8-(Rud+t5YR!b0(JuWC+Nfgr7$vY5wI}g z8VQp|?dN(4BjA;q(`jpn1&!1#`U(KK=Li?yYP$9gmDuWq*GWsu257Cuf~|V#^G|Zl2xZwehi)-(#zAkW}Y78 zDGBrgw0c`i4dz+xb!qD0YTsU1@Uo#F-s3W$A7;L{H--2-@zKUjVup7CfZ-}aQs@`y zmDI+K8a1m`H1;&TZe%%F%LsZTvE&P*`W%a1h1h6sbZAcrIA-Jd=3zbZ0Oyu-MNzo) z!1JOiK=lG>b*}-~A+bmwwjGkn0|+)x5|&>-u%v!9rQxnD6?w;(pG5fx9kaNOECFQ^ zWNUi&1$UV@T0W8;|1hBBS1BtV$N{&yZvi%q>#uTr>J$g`H`eFYO?B%u-Bh2il3rA2 zTJz@%hany!M<(%Y9rX@L{Ba8EdW;tpti5EG8s~=ruaso8KYACsOgbY3`UazQpv?3Q zO}SnuHI!Q08kt(JR4@4FD~kT%<6K7NxI_4-_w+*=1 zy;lpw^zNEp>LdcUI2KhDF%UY$x)xlCdSGa=jBbadF}ou~N(LiPHQ|}i z4Z}{TPLRhhqCI+3*yZ&*RBlSn?k)FOFUA>yv^PqHNmZnybVm{$T6So~2*sEiq42~e z_>2q1N@6U>jkiAZHeVPmvD8dZBE@yqDXApBYl38`q68z1F*4`~uc`Or)%qe&be-O* z>1aI%ID7WzCQ{24I{KRM*>swsbjp5gg-P1Av0=s3Y^)_jkV{m`Dl+tdwPFjN#MAIw z;uC&Z6S+WwMZjCs;6#0z>UU|{cvL-s8o3AD)Mrjv)!^OAmfAvgwSjJmU5zRi*IU6( zil*l1D;s&W|{}`I%v(D@RGwy0vIFM7uurFsW;sMC}9G%3qNO(d_ zX!sG8JBFcGl*Z^!tU&7n_Y7cTUeC9Utdev{{Y69g`%NFS||?7NA2QC(60EXe(3_fB`Bho+=ho^~$P(|IEAru}1pKZLIx zbTmmEV0;$ZkXV0@We(MC6ww)J4+!E^JkIRs7zZG$hT?cKu_X>_jA<1Te=t(b56kJb zy!KYC39j#<_#=0D^y2Up@6cm%bxZ;O80{O)PIl!tx&w3vs;Ln$<-=aBNft(`7v=lBX^3{1qW(f%0>RGpt#>Lq8>R z;ZUtow-A@23_MGn`2C9CcFUgXQb{n|zQg9DBqsb~!#*k32bh)dJ)CX^6$+s1ZA>a# z)g^g%YEDr1ZrrL{qs>2p>S5w&`cI1RCty7IWl8&X^IYO57fu!gM6RY`Q)WeX7tY7m zlO{457ouqKf&TA)3VwC?}H2678 zlj65O&aRV>UR~V&IPy}Znk(gZy0ET1+4XO~q_Ex{oa2SS0-7tu3!^l>?0KM1RDQs6 zFSJKDT|hdzeKkE|Aadrm2aMr|PXuiKkK^U9z!pnU;{`)^aRjucz5k-y`v*cS(=EZ_ zY~d^U&++RB0@@JM@uU`K9MywJX&2>ShE`bDEob#Aa1I`OQpYQbG$FP=ZZwUX!05G{ zf$xYiu%;R9W|90BPagsf?_^ zL5du_m;q}{McO+e?e;5AL$iM%b&cS%xFb-q_egf0!oWOGaf}J4)cldx(EeN%_T;M_ zOKq>Ge9&7qf^c->4S;mJefkizOHS>Y{Z?~qspq2X0u^;g2z9ev1~UnV`P>6kghiDr z z7X{V_iD^#~HZO>n4K}OIitEd&>oRohp2=P`@7O6?wrm@IRe17umJEOovKABBTdvuV zqAR#)*ec_nho+pT(SPhC*(2NwvuJJe$BfP4szTMQHbHM$(Tc?x_6VF?f`2I<*=z3b zU^w6^FrMp05XQxRkVlM&5{RaY)`xJKISS-;ZF$XspE1p`U&1JMvWvxRv>0n8uX|a( z{~EpKn~Gl;Az2?FlMJCuJ&?S%YnoOys}q&cg)wCK8b&Nl%a*EPM*3;;m^C7W-OUYS z<8zR->f%Z-y`F1_y<3Kbrr2N_ID`i36m*jY4Ys=6NxC9F9B80iIOIr0l%X}gVybEa z%dC>7A!>vhZ!{3+z(L;gDN>b*b>)KN%ueGY?Gr8DsOR#KyyO))StGS_Hz^;2MWJ+13ss+ItXW+5IC-?N3ha=%EEnm2-mxz&>uQFAdk5 zCDso~wx=YjPnvDye_;!Q0GEEoLz8%@c3D%&0vSQTC$g{&+=3wq_z`Dl?Fed<^&mWX zUjz87YMMFsIW8i6j`H^m{P-x)SGgq<|0p}wc8>HMJuxLFC+9KIIdP&xm5C2eYsK!- zn3%HPe0qOjbZ0=ySy%iJ2ffU^bq+$Urt>x1{n^ntvZtO|iJP^2;J!Q}&>Kl+e{EC8 zFnR}~Hr|yQHV6z2DgTdRA+kkK%|ZxiupumS^ne32azKPwt&R~=!ywsI|0_TUU$+4Jb68~Bu(m^Aay@ltN@N(hYp#*^-5 zf}Zs>JJXRp=d;l^?r!0PtqirXmak*k3VJ4d8$m6X=vDht&uGFt7kflQuIn$EOfh{T zA;tCpf3I)aTxkEKZ|R3e=Xd+Wfe;lsVBMWeDKrYu0Z;r?O+ALv=^@BgO4}-tEb=g9 zy*ZatEPZS{(<45z@loNYeS(U{+#zJTn}qBw;+SAU-~6f}rS9lr?)8S*+p`}3-0??l zulwz8cPH`n0*M~yTiB#Ixseqcw$17`?RC%2)}A)z?n~WsH(+|(stv4v>%+p2YxsHB z$3+wKDr@e*x|KthyP;Pu*pst7Et9q|2*KBEsrXNO$a>1SRZ7cKI_m(WOSsroL(*-4jIkrNr0z;5jRT5(@hBHJV>D)k;VFnRy7>r~}0G+)#5t#3F>GMq~69{>K`* zjBv_9A+cN2bz#*|miQ@D+i2`2gZ1$X>$b)e#m&afS53L|2iPAEK=!b=dxL;_0wGor zp)jfn5%fkX`H-V+)ldZEbzDn2k{8Jn`{D~6=(jOidmg#`LNcB@7LD{;CpM9k{IQRA zRaALUG0+(0Osz*YErl7+l;n+Q5mE}>f|1$huaTxq@)0+ETbPsEL{`#nVi8+n5ZoW3 zrEvdWk(q%R^7psI!6c*H?^wZ@J`lf4HG>R~OvZU(ln_^alE~YQsb5J=eroy&)P}`z zP|+TuJM34;d5zaCFXUShp&K9~sYUy2x&!=)aiMKIMjXSJAsRX3D3o(U6@#cz4Xm(=} z93Wt(>o6S=$de8!p=!9LM`2|(;8s=AbFrcH|bi=a6|cME^`}e6U`4y-?PiDY&1cUWrcSH{BKwJ zGu9&fEQP_b2U`G2$c>`Eey=1gjVn$@Z{hUCjk2{OJG;B=@6k8w@(Bp+0z56G%}y-) zg}(MwR>P;dg+8$#>@RQsr`x~aw!+(+q!?}#Y`;rcV)SM_wq)Havczw_nmSVhxAk^f36?h>b68P(fD&7p;%Qw!S1%)V zpVvPC?rV4}m(g43B<~H~E#=;mnmwuJR#tka8>om|3!Nt_t z@hspG=ilXWW8X*Cw6I$ccEb%ODflzj#zVSBMf|L&8_l%8w$hJTuSz=2Z%>OpQBNPi zsUP_=%pYNze1E5?ehIGlOyeN1J=9UUPs74rYUs6kDAe|9GqOjw%}?40`G^ayST?6f zIa60VcO7knj=^fZ{H@bV_46LX(#yYoZx3v(*2H-!HyNs6;FaA(OP}U7Mg3!5+|Rc* z;t2B9(#>FZZWHo+2SLfFofG?TzETmPS%}h=^^UV5Mpfl}AN63DF`Ae)Sdn@&ig?P4 zIYa4}=x~|ERS%hn)C*u1-)BzC|AtlOmZJadv7to7CW>2FuDjqD3xFd3^B0THzwG8W zaE{TX^a7j@`_^0sFRox?um5>-jlbvH6#`()G2_RUJfTiD7FkN^O%z?fC4!kSa~96% z+8kf2uN;AdDQ#YS-A0J-s@ntse^4yaGS; zSHrb&-Y)vIMw}E=i`BH-UoDp9h(ZaCrF4bK-e55zAW+it07RZ{JK}^&1vJD zK@#OG{O@E1vanpWa535vRb3Rl4Hd_5hfxlxsvAmja0NDjDFr%kPNYv&bs**-o%~po zQMXWu8X>V&2Zb^u++bqC-WRt?X|IsBf}+-97Yx9r_uug6_v^*SEe$7}opmxfQTr^L zEP`L7`GnB;&8R2zgBQJgk{Fc_xYWLx+hLE!BMb4Wq$d3LgQqGq*9&$Y_Q`Tl zcHC17m>O-TM*+QEBvPLtxofp7YiI9It?W3xYg(IrHJtftv0_B-P2emLS?J^&VZOvV z>YKIa|})5k2jf1er2=>Mr6snJnZ$Uxgr1nf*y#_HJI7*K&qksQLT67t~PF zR8en-of@s~i{P==<>{-n?51betMbg&;il79a} z>8p3>RzJ^es^7NTF;%%$TgXV>e8Pv!%VO6VjR;cU4lU8dxcq9bxl2cV$*7nOpENzw zj<`1#UePx`EM!{U_t;*|9)G{F6!g0dwk*!s(W2rl%neu0(Bb(C6&0hB&3F&oA~SW} z%k%@}2F9k4PeN%Pmqcc`7LwvQkS>ls%J~W1+MZF(US@`(&s~!ExwxRo##Olz*Y`QT zxHZ-f7-nYUO`PuDGme4qIp6id8aUq7IK8QgJi@5SchzHhII>+zPU?p6YM|Ye{n(37 z>sJVLAca7u4}7p82V*mr8H;J>*<0&b$l_M(l)+uMfW z%(xjhBiH5B>?k&Iva4H@HmMReiAl8k>*W@68loM%NNM^L066k9p7x2;Ds=)Y-r}H^u2nROo*3`h=-KeR92^f!Q@?|-r zH50n@64sWNSflUNo?Pl0^5D&(1?}_*?Zz;*6QCFr7ePOm;s!l9PMV|gyl1Z#Q*eF`rEg?!}VEF zuY@6Ny)?JU+X2^gv}4QcJOlsM|GiM>jpc4XF&q%DGaToapq;GAHXyXhq0eCxS4hpU zoWa7AUp8JlM-3(!J9+}UoK{aaq6&pNP!(4$Rm@pjhFj=H&0Iim#KoDNoHM5^STUE8 z0{ah6+d*0>I>{K~6(?sBTVtx1_q~i0l2~Vz8w{XI&*tH9p)&_R0^f6_!qXl!K4c= z3Uel!)KEl=cI>KQ?OP4>F(Tnen&_j}wu96xK%axVsB<)v0t58)dpOU;P+C|QO zBl|BR0cJ19C1F1~6Fe`cKrw6`yUn<@%dX$7?me>&mlHND8xCvInY^mjr=kfxs82y= za|5G*;Ar*nYw)4HsoO&nHr;y;zwA%+Ct$4k>lNdEoPNfGq@cWFN=H$ispqoiZ=0Y@ z6^&pCYZ_WpGcAip^zlJVHQ%yJjVQD6_fSip=A>@GGWKAd1H+V(&K_>J`Y<|>ZiAIr@;glE$$MC#83oq6%Qg_ zhi5>Oj)IU?j$-smJ(GhsrP|7pFM?cCF>-`x(D*1IrQmTTxkMGAD30yBw?%j&*b>u7 z*L=awx!y5LX|U%po$Z9kFu5p>=Tk5=nuN`_L$jDBGxQAicqgM6AlyhhICChAFXmcD zrd~cCR!1fG;pQIXV-cGZ?D=mj{CM5{e8;ojUaOU_btR6r&jRy}sz#cyOK33X4lWmk z76Q5~sCwm$ifTm_2cfu{^AuYsfrDZWsU}ggY}<A6_7QX_G9>tRVYCd@Tf^)lTm`Pd*lyl(gQ&Z7 z5^Wv0h9b5?_E0{2fLL-T_H=adfWJXk*6l`E>(XATjbqc_z^O@+6mIR*ZB@*0h2N{g z?bK{XSBu>}H>PUUj^~jI9giM}O>iv4`NF?3*D?lEwQ3W!eFt z4^Y2~ysEpNT55h?Je1vKYBvK z{y_V^9lWYey$>GQE)y*5rvhbPmKcO~lH&*km_vDy9EN+r9W zYX+&cs9`Gpv&w#}D2pGrfAzJWPl<#4cf~(Xwiu+YH?Wg_B+T#Y*x$}iU}EjD{5>*E zx?nWK7`-P-xi}<25dcjKRPvq*h)smU`ol?=YAbFTl+g%WHnC9pj{`3Fe+n{qa2~Y&#D~Hid3Wp}nCODBjpjYnNZ&Ehuj}#(E;}ov!+Z z-w}uI{^qtFflXpP!C#TJbNB6vYZ2YPOV^%jB#whz5MSKP7W?S6Md7GL@po`uUNU~^}F&OIk*!{@GA z%-8LT+d-eU0j;=hx4pOEI0BCzyFLuBufISyPoHs{*KcvVmk3;R5pHK-*MTkiUy*imM;Srxk;BOWp+^(iUegR!cb!YjTl(zosJzoYk&!O@EfW_4!5 zE<8p)lG1UUOqm1b`W14%TPqGU0ygL79B=!>=Cgw^=oh6YcLs0v-|Poy3z(=>sD6(x zY6fW{ic%JYng#E8M|(lo)I6nBgx}kK&4xZZjHj(De5Cz3430~9J9TM?BDmssEqE|I zJB9zf2H0ylx~DA6s+SzZAG`zg%=c*PzrzoUo1iO@+EKci*BgK~MB1~P`!(hKWHQhj zM}=1f1merW^1LCXs7!zVIkh+N2ltBvVI{KyiDW$p zeOUyxD82fn0BB(?n1}WNdI(bVp7Y(aS+}5C-sQC!*~_#>ezr@DpD&s4w1FUbpSVE@ z45!pED=vtEQ|abc6d_p@Ou$SRY8c>|iVu6#SQ>OcwvL`m~*LACIxS{Lx_X% z$tI^;+PKCz2>ycsUc^ZtJl@&K1>6C_*MhNTV~VNGOx2!xQD*(R6OUJ=_aD>mxS@LCpTA?YQCT3JfmTxTmelYPb zH8Ts)ej*ibw6mKelFfXI1J)zhsBz@p-YIYkL8SXc+HbseNNC$!W5#~c+-U~FGO4R& z&R=p0GzTl|zypID3=bGfO&Iqn8uMcg8H2wKpv#qDfvQ^+ds0vfP13Auc%}rVRh}_M z(k-VN@SWsE9$EwN*B(XSh9HpDPPq9ug_Tfkbf;_TbsADqWZ{EN&FW8%G0CNrNlLiE*GrVFS4w}f3+F$5 z=7h=g2@K@QfMA?d)yel#NVP@Hi}UI(gq){m{nIdrPsp@vwbR7AxfWk4IzBQEx8HH! zWVQHeFn^!N*Wr3K0l|;M=XUg%e10F-$C|mn-~8eW?i5h7;l-o%ii*Eb^mwtC4G z;6ya6%lPZQl2ciOjOXh8EZ+A+UCRs zN7Yx+S0KIYev>IOKUNwO1qJ|pq|22RTdL-`OY$jmJRitUpg}R2Zp^ESM5OS`WK~E# zE(Mxzexaz?*UKcDSKV|!C4MGT6GncK^{X*7e1XieM`ay-S1OCeV++EQ_u>!U>A2ge z1!e|XkwWV{_D+=BuuBg~C0|j4&uS=R-+koP`A070)t{dFU4n5pN?m@3qWW7f-#M6` z8zA`O+9g+zvE)FU=N`S~mZAPs+qR|W5R2t08}=K_F8gp^@A;eX!fTg};8qtdkgi*f zTIM^`wI=SKzx`>8=Ul;oryY%_9<~bz-gf1?jvG@q8Fi~q-C2u1O1GvO*%VzH)ExPQ zsnf?PwA^HW$qSTMpf%+N6uA#j6xduNSvm1fF2-`N+Zbi?cXv_=2YK0>Nl`DA!PmUfTW-#Un0bPIWa%KQC}TW|P}` zCuj6vS{{AX9O=TxGSG+ajuCgrsR=MX$+)52w`#e<#tLQVp37D@wQPEi-@=y~4+BvT z>KuLfx?T}sfq$P@oT^>^1{kY@;|)83aVZu_#~R6q?!N6r_M4PsjjHl;q(!Z6+R#zEje{1{E&-7skd4|G!~ug2c0zwBfS(;R|r1bL1%(x}X>Jl|*oY8FC$yK3<9) z_@alAJp4WwiPs<}N^<4oi;j9B2#*c_d}B*V^5qWh>$tA~N%NscWTsRil- zxIDT*IpYb>`p8Q>*Ock+UVPyr_W2#OGi3^vt z3jc_ulH~kqPR8J%yGbfng*2Xd{oalum?Ve(yTmJb)m_F0EhNm0@Dr1)^M!7w%t#t%$JohjX6 zgv=qQSL`)RoKLK*K}Sw0t!WT+7Z{vUr90xhpx z{SQEc509>_)hk_Y5WWmw2AClklU_K|0cN8!@T{X$!0rpoIoxBU<#Ue@294qmonY|> z``ha}6~(_&NHID;BCMO@D7{EE12K-Z-n-={{tR^le=GcgP4F7jrVTTj1#SYHw3hf&gJj zD})=z6sYh!Ya(iO$+03)Zr3pLcr3nwRqLxS?2$dZ=fIEoWEya(zt6S&b=3Q1t)2-e z==$PNBu3JaU~DLY44Vk2Cw@GJrLoTp42T=G7i+uF?#33_^A@pV}fa5`HjVWb1L?YYpVs*XI=6(7{%K_ zV>9;8l)rbY|Ql0mW#cF6Y_{(@~V-g&Zo^tI)bmV9=fo-1}9bIL4106 zt+kz6s+qs6#zcf6R7v88bJ&fF-TNzSi(6widTTfAtQuCTuegtQzbl;>7Rm)10|q)v z|J_G5TBDkUcBq?J;04q2Pf6NuIY=ur?K2y#=>LH0WQihS7{EUjWrCqB6`B>T5mkfvn=Xo#VBm^fiQ{M>HpAEltP zlvRIeOxZp!yQeK;Mpr|G#~|XiWMK@`%Lh!W45AyTlsfzuEQT#C0B@mEP|S#Y=z$93 zb~JRTLn=YnOcIAhv;42EizdghVZYCkOAfY7y;7-XAjy;V_V_<|u|bUaopD37u*M5M zQiz1vaa+}WHQ>s=N+z19ax{Kg5Xt6t9Ty)B+PqLfWd(2&p;q9oY{H5^p2J;`p1Fy5 zVnhE@$Nb!6Fu8$pMo7L19Mvue;@uI>CN6MUv~66U(_FiGF%^DCMcXRkHpC@umf(}; z^NDORxusK{4l6`qu~EtkNOBAgj&{{l3Mo9SZ1mS&juDD8*!-xa9(LipiX`M>#Gm#X z-D)`tSNjD1DFe3D&AyP&YhtlUWSc;%@B5{T-I9ZmH=+54&(Sp2U5pgoi@DFKeczDx z;o|n-tX2Sz!C_S^r;MQTn%kpH@l3qEl~Gqn>02Tp#l=P!fAdX=v6Z0B*=AO?y_W1l zmm2nMb&N;yj_cI9t{F_nCT)o$+ScUtq1(k?m5mSNTo_+vI46-b61mJQ`7x1k&lw^6 zFJxj==5&Ojw|}ehZ_JvJLrciN4qWUlcvU)RY|fFoOJ_0mk8q?QYf74~=6Yf)`}>uA z#lez30o$ypCj$4u;t|>*21=YoOZ||0Kbj2DcTzE5`FDNy=~6#h$8~@yn;UkpUyhw) z|5seB&>)%dkT~5qutF?ldjNUt#P4vnZ_R%onghh6^fHT zyLD0L`YeaMuSxEEUzNu**k71*0zw1pBW<49kZ9jB*oQa+G>cF>Gv1LzsKx|{>3<=` zm|Y0)pwWT)_Wy$vb8hZSro2GES5_9R|9}qaVm)T_U9p4x@1U5M$_u^Yd#$ZR9qS1W z)p<$&;NmRqO_%mAQ0_a+9N;`tg?B=xVtrVJA)xpSb3x%I~?ytsP6J zp>lrfO}c2?e-qi{t;vfOOD&{D1`qi=c+r%30;@@3N-u2nVYPN4l0ucSyUW|GbEo1j z*I{TWdTi`g%O1?=3V!WOzn-qJSLMA5Y7d|G{)PW@r8v+^a~<61e7|bvl{mMpHFV7> z`QS#%3tzVeX6qo@_VeoAdS?_LNtir`jzj)rT`_5l+nZW zSE%bj2hTu$=kNDRTy7hJjl1&g%ct&M_WEr(`ypm})4wcmW|+Y~NG9}PJ(QWTV%hoJ zc@kJU32bB*+qZ|Hmw&7X#_Use2cd}w@|wJ8%&@pvmz)VR{^R_+o`s|NB(+eO*QaA|Y(aC}9Wacs(R;ML~Qk3&FdY?W@*hM?;zsvck zGHa-6uA`i#B@t1I{87-e%&kmdJ>3!K9$`!bqKCn~T4g*P?=CUEK&|QWB6!;=@ft#w zrdyH9jeUH?VMhH>9CO?ZDtzh$!Qr}vWpnq0ui7u$#tYG1d;Cbm0RvfYE95u)(-L|I!3OJT zvFW#q)n2p&w~t;&9a1lPCYrcQAh8*FHM5;dU)pQw9~@`wzNy={>mGy;Z*79$vzFRQ zz$vHx>ejXyjsW>#DDRT%w-)*D%@9XxsEaSrpx#{D zha2H%9>#0qF5Gqjz1Lu%zuN~xdm#y)IIK`cu-@)%i+8rSHkovXrM>sB&&0*nT(`Y& z-Zkr&{rttIZ3{x3uBCHV!=3+L6NXMW`j^9E$(@&d!P+jgly2j2=#D*#&R@dgZYJ8< z0|nD;;Ez}TXG>Txb{@_LLu_e`jLN_oHfQE*`bcDWeVsJsf}1+28e<^})4&(g&Yrl8 zQ2l7}d+Pk0{a@o+ey?xh-16@w{m=cs=k0_*UY_5liI}G?aMI6I!9i4i)z#nkT7DrB zE`@>GI(e0aHhJAcSaT8o#^Tc29uw)j+ByY+74vAtmD|48%IP$Fb@Hf$b>Zx|CW#6k zvLh#mRFzw_CSAU7#TD~#9ra`!+93;|v4b`U%*B}S=m3A_583LDtD7sk#GF6X5MJ(G zk1F>PhRJDF@8R^Fhhyc{cNrD98~aX2ImLD*pST9k<3E27Qnz;fB2>2hxH5(3=ZLQuMVdIOTIakhmK26Tt;015Y6}zLTht)+6pBMX$u@I#Lw*P^p J^hK?(lS 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

u_elOo2MUZ_Wm;o7lzcn<4p4&*yHX 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%0AVG?kqapax`NPO3zhEr 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 z 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 J^hK?(lS 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

u_elOo2MUZ_Wm;o7lzcn<4p4&*yHX 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�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≪ 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 diff --git a/contracts/api2-contract.lock.json b/contracts/api2-contract.lock.json deleted file mode 100644 index 0e8a188..0000000 --- a/contracts/api2-contract.lock.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "repository": "https://github.com/transloadit/api2", - "revision": "27622f3ecd09ffef6fc86a43dcfe14b95deaaad6", - "path": "api2/generated/contracts/v1/contract.json", - "sha256": "59c41853f194b01b6560f57a696afba89d774281d32f80d9ed03de724895a2a8" -} diff --git a/docs/api-coverage.md b/docs/api-coverage.md deleted file mode 100644 index f78b110..0000000 --- a/docs/api-coverage.md +++ /dev/null @@ -1,111 +0,0 @@ -# Python 2.0 API coverage - -Python 2.0 implements all **44 documented operations** in both `Transloadit` and -`AsyncTransloadit`: 38 API2 endpoints and six raw TUS operations. Async ordinary -methods are awaited; `stream_assembly_status` returns an async context manager. -Assembly, Template, polling and tuspy upload helpers remain maintained by hand. - -The initial async draft reached 22 of 38 API2 operations, including a POST alias -for Assembly replacement and partial token issuance. The new methods add auth-key -management, DAM, statistics, canonical multipart replacement, SSE and raw TUS. - -## Reproducible generation - -`contracts/api2-contract.lock.json` records the producer revision and SHA-256 of -the original contract bytes. `contracts/api2-contract.json.gz` contains those -unmodified bytes compressed with a fixed timestamp. The pin is API2 main -`27622f3ecd09ffef6fc86a43dcfe14b95deaaad6`, published from -`api2/generated/contracts/v1/contract.json`. The SDK build does not require API2 -credentials or a network request. - -```bash -python scripts/generate_endpoints.py -python scripts/generate_endpoints.py --check -# Update only from a reviewed, committed API2 revision: -python scripts/generate_endpoints.py --api2-root ../api2 --ref -``` - -The generator consumes `apiReference.operations` and the corresponding dispatch -and exchange records. It derives HTTP paths/methods, transport kinds, stages, -token-grant authentication, protocol header defaults and SSE terminal events. -Python compatibility names are the only SDK-specific method-name overrides. -CI checks both client blocks, transport metadata and this table byte for byte. -The 102 public dispatch entries include guards, aliases, routing and separate -products; they are not 102 SDK endpoint methods. OpenAPI is a served projection -of the canonical contract, not a checked-in `openapi.json` file in this pin. - -## Documented operations - -Methods accept normalized request fields as a `params` dictionary for GET or -`data` for other ordinary methods. Pass files/extra fields to Assembly creation -and replacement. Response payloads remain dictionaries rather than generated -model classes. The server validates request fields. A covered operation does not -mean that every response or server-side permission has a live test in this repo. - - -| Operation | HTTP request | Sync / async method | Stage | -| --- | --- | --- | --- | -| `api2.assembly-stats` | `GET /assembly_stats` | `assembly_stats` | | -| `api2.bulk-delete-dam-assets` | `POST /dam/assets/bulk/delete` | `bulk_delete_dam_assets` | alpha | -| `api2.bulk-move-dam-assets` | `POST /dam/assets/bulk/move` | `bulk_move_dam_assets` | alpha | -| `api2.cancel-assembly` | `DELETE /assemblies/{assemblyId}` | `cancel_assembly` | | -| `api2.create-assembly` | `POST /assemblies` | `create_assembly` | | -| `api2.create-auth-key` | `POST /auth_keys` | `create_auth_key` | | -| `api2.create-template` | `POST /templates` | `create_template` | | -| `api2.create-template-credential` | `POST /template_credentials` | `create_template_credentials` | | -| `api2.delete-auth-key` | `DELETE /auth_keys/{authKeyId}` | `delete_auth_key` | | -| `api2.delete-dam-asset` | `DELETE /dam/assets/{assetId}` | `delete_dam_asset` | alpha | -| `api2.delete-template` | `DELETE /templates/{templateIdOrName}` | `delete_template` | | -| `api2.delete-template-credential` | `DELETE /template_credentials/{templateCredentialId}` | `delete_template_credentials` | | -| `api2.get-assembly` | `GET /assemblies/{assemblyId}` | `get_assembly` | | -| `api2.get-bill` | `GET /bill/{billYearMonth}` | `get_bill` | | -| `api2.get-dam-asset` | `GET /dam/assets/{assetId}` | `get_dam_asset` | | -| `api2.get-template` | `GET /templates/{templateIdOrName}` | `get_template` | | -| `api2.get-template-credential` | `GET /template_credentials/{templateCredentialId}` | `get_template_credentials` | | -| `api2.issue-bearer-token` | `POST /token` | `issue_bearer_token` | | -| `api2.list-assemblies` | `GET /assemblies` | `list_assemblies` | | -| `api2.list-assembly-notifications` | `GET /assembly_notifications/{assemblyId}` | `list_assembly_notifications` | | -| `api2.list-auth-key-scopes` | `GET /auth_keys/scopes` | `list_auth_key_scopes` | | -| `api2.list-auth-keys` | `GET /auth_keys` | `list_auth_keys` | | -| `api2.list-dam-assets` | `GET /dam/assets` | `list_dam_assets` | | -| `api2.list-priority-job-slots` | `GET /queues/job_slots` | `list_priority_job_slots` | | -| `api2.list-template-credential-types` | `GET /template_credentials/types` | `list_template_credential_types` | | -| `api2.list-template-credentials` | `GET /template_credentials` | `list_template_credentials` | | -| `api2.list-templates` | `GET /templates` | `list_templates` | | -| `api2.move-dam-asset` | `PATCH /dam/assets/{assetId}` | `move_dam_asset` | alpha | -| `api2.move-dam-entry` | `POST /dam/entries/move` | `move_dam_entry` | alpha | -| `api2.priority-job-slot-stats` | `GET /priority_job_slot_stats` | `priority_job_slot_stats` | | -| `api2.replace-assembly` | `PUT /assemblies/{assemblyId}` | `replace_assembly` | | -| `api2.replay-assembly` | `POST /assemblies/{assemblyId}/replay` | `replay_assembly` | | -| `api2.replay-assembly-notification` | `POST /assembly_notifications/{assemblyId}/replay` | `replay_assembly_notification` | | -| `api2.show-auth-key-secret` | `POST /auth_keys/show_secret/{authKeyId}` | `show_auth_key_secret` | | -| `api2.stream-assembly-status` | `GET /{statusStream}` | `stream_assembly_status` | | -| `api2.update-auth-key` | `PUT /auth_keys/{authKeyId}` | `update_auth_key` | | -| `api2.update-template` | `PUT /templates/{templateIdOrName}` | `update_template` | | -| `api2.update-template-credential` | `PUT /template_credentials/{templateCredentialId}` | `update_template_credentials` | | -| `tusd.create-upload` | `POST /resumable/files` | `create_upload` | | -| `tusd.delete-upload` | `DELETE /resumable/files/{uploadId}` | `delete_upload` | | -| `tusd.download-upload` | `GET /resumable/files/{uploadId}` | `download_upload` | | -| `tusd.get-upload-offset` | `HEAD /resumable/files/{uploadId}` | `get_upload_offset` | | -| `tusd.options` | `OPTIONS /resumable/files` | `tus_options` | | -| `tusd.patch-upload` | `PATCH /resumable/files/{uploadId}` | `patch_upload` | | - - -## Compatibility and 2.1 boundary - -The five staged DAM operations retain their producer's alpha designation. -`create_assembly_with_id` remains the accepted POST replacement alias; -`replace_assembly` uses canonical PUT. Builtin Template and invoice helpers are -variants of existing public operations, not additional operation IDs. - -The inherited `get_template_full`, `get_builtin_template_full` and -`validate_template_credential_oauth_on_create` helpers remain for compatibility -with the draft. API2 now classifies these Console routes as internal: they are -excluded from public-contract generation and the table above. Use the documented -Template and Template Credential APIs for new integrations. - -The 16 storage-management, device-authorization, OAuth and self-revocation routes -marked `separate-product-surface` are deferred to -[Python 2.1 issue #60](https://github.com/transloadit/python-sdk/issues/60). -Delegated S3/MCP/Companion/Socket.IO protocols, dispatch guards and operational -recovery routes are outside this SDK endpoint surface. diff --git a/docs/source/index.rst b/docs/source/index.rst index c29738f..9a28ab4 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -113,57 +113,15 @@ releasing caller-owned files. Multipart cancellation drains active file reads. Timeout and shutdown cleanup can therefore exceed the requested deadline; keep file context managers open around the awaited call. -Endpoint coverage ------------------ - -Both clients implement all 44 documented operations: 38 API2 endpoints plus six -raw TUS operations. See the `coverage table`_ for methods, HTTP routes, alpha -stages and the pinned contract generation/check procedure. The 16 separate-product -storage/device/OAuth routes are tracked for 2.1 in `issue 60`_. - -GET methods accept normalized API fields in ``params``; other ordinary methods -accept ``data``. Creation and replacement of Assemblies also accept ``extra_data`` -and ``files``. Requests are signed by default; pass ``bearer_token`` to use an -existing token. ``issue_bearer_token`` also supports authorization-code and refresh -flows. Automatic refresh is not performed. - -Isolated transports preserve network configuration. Sync calls honor environment -proxies and ``REQUESTS_CA_BUNDLE`` / ``CURL_CA_BUNDLE``; async calls retain an injected -session's DNS/TLS connector, explicit proxy/auth and ``trust_env`` setting, or use -environment proxies by default. Public, token, SSE and raw TUS calls isolate cookies, -default account auth and netrc credentials. Explicit bearer authentication takes -precedence over netrc and injected session authentication. - -Assembly get/cancel also isolate account credentials. Custom ``service`` deployments -retain their returned Assembly worker hosts for high-level polling. The default -Transloadit service restricts these requests to its API hosts; neither mode follows -redirects or accepts credentials embedded in URLs. -Legacy HTTP ``assembly_url`` values on known Transloadit hosts are upgraded to HTTPS. -Both clients use the pinned contract's regional-host pattern. - -``stream_assembly_status`` takes the returned ``update_stream_url`` and is used -with ``with`` / ``async with``. Iterate its events with ``for`` / ``async for``; -the context closes the connection on exit or cancellation. Unknown events remain -available to callers. Terminal events and disconnects do not imply success: -fetch the final Assembly Status and inspect ``ok`` / ``error``. HTTP failures -raise ``transloadit.stream.StreamError``. Read inactivity defaults to 120 seconds -and event size to 1 MiB, adjustable through ``read_timeout`` / ``max_event_size``. -There is no automatic reconnect or replay. -EOF ends iteration even without a terminal event. Network failures retain the -underlying requests/urllib3 or aiohttp exception types. - -For raw TUS, pass the Assembly response to ``tus_options`` / ``create_upload``. -Creation pairs ``tus_url`` and ``assembly_ssl_url`` and returns a validated -``upload_url`` alongside the response. Persist that URL for offset queries, -append, download and deletion. Pass protocol headers with ``headers`` and upload -bytes with ``body``. Include base64-encoded ``filename`` / ``fieldname`` entries in -``Upload-Metadata`` when creating uploads. The client adds the Assembly metadata. -Downloads always return bytes. Raw methods return HTTP errors -as Response objects; inspect their status. Existing high-level upload helpers -still manage normal uploads and polling. - -.. _coverage table: https://github.com/transloadit/python-sdk/blob/asyncio-v2/docs/api-coverage.md -.. _issue 60: https://github.com/transloadit/python-sdk/issues/60 +Client features +--------------- + +``AsyncTransloadit`` mirrors the existing synchronous client: Assembly creation, +retrieval, listing and cancellation; Template creation, retrieval, listing, +updates and deletion; monthly billing; and Smart CDN URL signing. Use the +Assembly helpers for multipart or resumable uploads and completion polling. +Await the async client's network methods; local factories and URL signing stay +synchronous. Examples -------- diff --git a/examples/README.md b/examples/README.md index 22f49e4..4253a14 100644 --- a/examples/README.md +++ b/examples/README.md @@ -26,13 +26,6 @@ Transloadit and may create temporary Assemblies or Templates in your account. These quickstart examples run in CI against a dedicated Transloadit test account, so they are kept in sync with the SDK and API. -## API2 Contract QA Examples - -`api2-devdock-*` examples are runnable usage examples that API2's contract QA runs -against devdock. They expect API2 to inject a scenario JSON file via -`API2_SDK_EXAMPLE_SCENARIO`, so the API/TUS facts stay in API2 contracts while the -example code remains normal SDK usage. - ## Advanced Examples These examples require pre-created Templates and, depending on your Template, third-party diff --git a/examples/api2-devdock-assembly-lifecycle/main.py b/examples/api2-devdock-assembly-lifecycle/main.py deleted file mode 100644 index 2c66790..0000000 --- a/examples/api2-devdock-assembly-lifecycle/main.py +++ /dev/null @@ -1,173 +0,0 @@ -"""Run the API2 contract Assembly lifecycle scenario against a devdock API2 server. - -This example is intentionally checked into the SDK repository: it should read -the API facts from API2's injected scenario JSON and exercise public SDK -methods as normal user code would. -""" - -import json -import os -from pathlib import Path -from time import sleep - -from transloadit.client import Transloadit - - -def required_env(name): - value = os.environ.get(name) - if not value: - raise RuntimeError(f"{name} must be set") - return value - - -def fail(message): - raise RuntimeError(message) - - -def load_scenario(): - configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") - scenario_path = ( - Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") - ) - with scenario_path.open(encoding="utf-8") as scenario_file: - return json.load(scenario_file) - - -def response_data(response, operation): - data = response.data - if not isinstance(data, dict): - fail(f"{operation} returned non-JSON data: {data!r}") - if data.get("error"): - fail(f"{operation} returned {data.get('error')}: {data.get('message')}") - return data - - -def assembly_result(data): - return { - "assemblyId": data.get("assembly_id") or data.get("assemblyId") or data.get("id"), - "assemblySslUrl": data.get("assembly_ssl_url") or data.get("assemblySslUrl"), - "assemblyUrl": data.get("assembly_url") or data.get("assemblyUrl"), - "ok": data.get("ok"), - } - - -def list_items(data): - items = data.get("items") - if isinstance(items, list): - return items - - assemblies = data.get("assemblies") - if isinstance(assemblies, list): - return assemblies - - fail(f"assembly list response did not contain items or assemblies: {data!r}") - - -def list_count(data): - count = data.get("count") - if isinstance(count, int): - return count - - return len(list_items(data)) - - -def item_assembly_id(item): - if not isinstance(item, dict): - return None - - return item.get("assembly_id") or item.get("assemblyId") or item.get("id") - - -def write_result(result): - result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") - if not result_path: - return - - with Path(result_path).open("w", encoding="utf-8") as result_file: - json.dump(result, result_file, indent=2) - result_file.write("\n") - - -def main(): - scenario = load_scenario() - endpoint = required_env("TRANSLOADIT_ENDPOINT") - client = Transloadit( - auth_key=required_env("TRANSLOADIT_KEY"), - auth_secret=required_env("TRANSLOADIT_SECRET"), - service=endpoint, - ) - - created = response_data( - client.create_tus_assembly(scenario["assembly"]["fileCount"]), - "createTusAssembly", - ) - created_result = assembly_result(created) - assembly_id = created_result["assemblyId"] - assembly_url = created_result["assemblySslUrl"] - if not assembly_id: - fail(f"createTusAssembly returned no assembly id: {created!r}") - if not assembly_url: - fail(f"createTusAssembly returned no assembly_ssl_url: {created!r}") - - cancel_on_exit = True - - try: - fetched = response_data( - client.get_assembly(assembly_url=assembly_url), - "getAssemblyStatus", - ) - # The Assembly list is eventually consistent: the API acknowledges creation before - # the list storage row lands, so poll briefly until the created Assembly shows up. - listed = response_data( - client.list_assemblies( - { - "assembly_id": assembly_id, - "pagesize": scenario["list"]["pageSize"], - } - ), - "listAssemblies", - ) - listed_items = list_items(listed) - for _attempt in range(20): - if any(item_assembly_id(item) == assembly_id for item in listed_items): - break - sleep(0.5) - listed = response_data( - client.list_assemblies( - { - "assembly_id": assembly_id, - "pagesize": scenario["list"]["pageSize"], - } - ), - "listAssemblies", - ) - listed_items = list_items(listed) - cancelled = response_data( - client.cancel_assembly(assembly_url=assembly_url), - "cancelAssembly", - ) - cancel_on_exit = False - - write_result( - { - "cancelled": assembly_result(cancelled), - "created": created_result, - "fetched": assembly_result(fetched), - "listContainsCreated": any( - item_assembly_id(item) == assembly_id for item in listed_items - ), - "listCount": list_count(listed), - } - ) - finally: - if cancel_on_exit: - client.cancel_assembly(assembly_url=assembly_url) - - print( - "Python Transloadit SDK devdock scenario " - f"{scenario['scenarioId']} canceled Assembly {assembly_id}" - ) - - -if __name__ == "__main__": - main() diff --git a/examples/api2-devdock-template-lifecycle/main.py b/examples/api2-devdock-template-lifecycle/main.py deleted file mode 100644 index f9f9fdc..0000000 --- a/examples/api2-devdock-template-lifecycle/main.py +++ /dev/null @@ -1,196 +0,0 @@ -"""Run the API2 contract Template lifecycle scenario against a devdock API2 server. - -This example is intentionally checked into the SDK repository: it should read -the API facts from API2's injected scenario JSON and exercise public SDK -methods as normal user code would. -""" - -import json -import os -import time -from pathlib import Path - -from transloadit.client import Transloadit - - -def required_env(name): - value = os.environ.get(name) - if not value: - raise RuntimeError(f"{name} must be set") - return value - - -def fail(message): - raise RuntimeError(message) - - -def load_scenario(): - configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") - scenario_path = ( - Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") - ) - with scenario_path.open(encoding="utf-8") as scenario_file: - return json.load(scenario_file) - - -def response_data(response, operation): - data = response.data - if not isinstance(data, dict): - fail(f"{operation} returned non-JSON data: {data!r}") - if data.get("error"): - fail(f"{operation} returned {data.get('error')}: {data.get('message')}") - return data - - -def require_template_id(data, operation): - template_id = data.get("id") or data.get("template_id") - if not template_id: - fail(f"{operation} returned no template id: {data!r}") - return template_id - - -def template_content(content): - if not isinstance(content, dict): - fail(f"template content must be an object: {content!r}") - - rendered = dict(content.get("additionalProperties") or {}) - rendered["steps"] = content["steps"] - - return rendered - - -def template_payload(name, config): - require_signature_auth = 1 if config["requireSignatureAuth"] else 0 - return { - "name": name, - "require_signature_auth": require_signature_auth, - "template": template_content(config["content"]), - } - - -def response_flag(data, *names): - for name in names: - if name in data: - value = data[name] - if isinstance(value, bool): - return value - if isinstance(value, int): - return value != 0 - if isinstance(value, str): - return value.lower() in ("1", "true", "yes") - return False - - -def template_result(data): - content = data.get("content") or data.get("template") or {} - if not isinstance(content, dict): - fail(f"template response content must be an object: {content!r}") - - return { - "content": content, - "id": data.get("id") or data.get("template_id"), - "name": data.get("name") or data.get("template_name"), - "requireSignatureAuth": response_flag( - data, - "require_signature_auth", - "requireSignatureAuth", - ), - } - - -def list_count(data): - count = data.get("count") - if isinstance(count, int): - return count - - items = data.get("items") - if isinstance(items, list): - return len(items) - - fail(f"template list response did not contain a count or items list: {data!r}") - - -def deleted_get_result(response): - data = response.data - if not isinstance(data, dict): - return False, "" - - error_code = data.get("error") - if isinstance(error_code, str) and error_code: - return False, error_code - - return response.status_code is not None and response.status_code < 400, "" - - -def write_result(result): - result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") - if not result_path: - return - - with Path(result_path).open("w", encoding="utf-8") as result_file: - json.dump(result, result_file, indent=2) - result_file.write("\n") - - -def main(): - scenario = load_scenario() - endpoint = required_env("TRANSLOADIT_ENDPOINT") - client = Transloadit( - auth_key=required_env("TRANSLOADIT_KEY"), - auth_secret=required_env("TRANSLOADIT_SECRET"), - service=endpoint, - ) - - template_name = f"{scenario['template']['namePrefix']}-{time.time_ns()}" - template_id = None - delete_template = True - - try: - created = response_data( - client.create_template(template_payload(template_name, scenario["template"])), - "createTemplate", - ) - template_id = require_template_id(created, "createTemplate") - - fetched = response_data(client.get_template(template_id), "getTemplate") - listed = response_data( - client.list_templates({"pagesize": scenario["list"]["pageSize"]}), - "listTemplates", - ) - - updated_template_name = f"{template_name}{scenario['update']['nameSuffix']}" - response_data( - client.update_template( - template_id, - template_payload(updated_template_name, scenario["update"]), - ), - "updateTemplate", - ) - updated = response_data(client.get_template(template_id), "getTemplate updated") - - response_data(client.delete_template(template_id), "deleteTemplate") - delete_template = False - - deleted_get_succeeded, deleted_error_code = deleted_get_result(client.get_template(template_id)) - - write_result( - { - "deletedErrorCode": deleted_error_code, - "deletedGetSucceeded": deleted_get_succeeded, - "fetched": template_result(fetched), - "listCount": list_count(listed), - "templateId": template_id, - "templateName": template_name, - "updated": template_result(updated), - "updatedTemplateName": updated_template_name, - } - ) - finally: - if template_id and delete_template: - client.delete_template(template_id) - - print(f"Python Transloadit SDK devdock scenario {scenario['scenarioId']} passed for {endpoint}") - - -if __name__ == "__main__": - main() diff --git a/examples/api2-devdock-tus-assembly/main.py b/examples/api2-devdock-tus-assembly/main.py deleted file mode 100644 index af956ba..0000000 --- a/examples/api2-devdock-tus-assembly/main.py +++ /dev/null @@ -1,131 +0,0 @@ -"""Run the API2 contract TUS Assembly scenario against a devdock API2 server. - -This example is intentionally checked into the SDK repository: it should read -the API/TUS facts from API2's injected scenario JSON and exercise public SDK -methods as normal user code would. -""" - -import json -import os -from pathlib import Path - -from transloadit.client import Transloadit - - -def required_env(name): - value = os.environ.get(name) - if not value: - raise RuntimeError(f"{name} must be set") - return value - - -def fail(message): - raise RuntimeError(message) - - -def load_scenario(): - configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") - scenario_path = ( - Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") - ) - with scenario_path.open(encoding="utf-8") as scenario_file: - return json.load(scenario_file) - - -def response_data(response, operation): - data = response.data - if not isinstance(data, dict): - fail(f"{operation} returned non-JSON data: {data!r}") - if data.get("error"): - fail(f"{operation} returned {data.get('error')}: {data.get('message')}") - return data - - -def example_input(scenario): - input_values = scenario.get("exampleInput") - if not isinstance(input_values, dict): - fail("exampleInput must be an object") - - return input_values - - -def upload_tus_assembly_input(example_input_values): - feature_inputs = example_input_values.get("sdkFeatureInputs") - if not isinstance(feature_inputs, dict): - fail("exampleInput.sdkFeatureInputs must be an object") - - input_values = feature_inputs.get("uploadTusAssembly") - if not isinstance(input_values, dict): - fail("exampleInput.sdkFeatureInputs.uploadTusAssembly must be an object") - - return input_values - - -def scenario_bytes(upload): - content = upload.get("content") - if not isinstance(content, str): - fail("exampleInput.sdkFeatureInputs.uploadTusAssembly.upload.content must be a string") - - return content.encode("utf-8") - - -def upload_config(input_values): - upload = input_values.get("upload") - if not isinstance(upload, dict): - fail("exampleInput.sdkFeatureInputs.uploadTusAssembly.upload must be an object") - - return { - "content": scenario_bytes(upload), - "fieldname": upload["fieldname"], - "filename": upload["filename"], - "user_meta": upload.get("user_meta") or {}, - } - - -def write_result(create_response, status, upload_url): - result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") - if not result_path: - return - - with Path(result_path).open("w", encoding="utf-8") as result_file: - json.dump( - { - "createResponse": create_response, - "status": status, - "uploadUrl": upload_url, - }, - result_file, - indent=2, - ) - result_file.write("\n") - - -def main(): - scenario = load_scenario() - endpoint = required_env("TRANSLOADIT_ENDPOINT") - client = Transloadit( - auth_key=required_env("TRANSLOADIT_KEY"), - auth_secret=required_env("TRANSLOADIT_SECRET"), - service=endpoint, - ) - - example_input_values = example_input(scenario) - input_values = upload_tus_assembly_input(example_input_values) - upload = upload_config(input_values) - completed_assembly, upload_url = client.upload_tus_assembly( - upload["content"], - upload["fieldname"], - upload["filename"], - upload["user_meta"], - ) - status = response_data(completed_assembly, "uploadTusAssembly") - write_result(status, status, upload_url) - - print( - "Python Transloadit SDK devdock scenario " - f"{example_input_values['scenarioId']} passed for {endpoint}" - ) - - -if __name__ == "__main__": - main() diff --git a/examples/api2-devdock-tus-resume-upload/main.py b/examples/api2-devdock-tus-resume-upload/main.py deleted file mode 100644 index 1621f2e..0000000 --- a/examples/api2-devdock-tus-resume-upload/main.py +++ /dev/null @@ -1,203 +0,0 @@ -"""Run the API2 contract TUS resume scenario against a devdock API2 server. - -This example is intentionally checked into the SDK repository: it reads the -API/TUS facts from API2's injected scenario JSON, interrupts an upload like an -unlucky user would, and resumes it through the public SDK method. -""" - -import base64 -import json -import os -from pathlib import Path -from urllib.parse import urljoin - -import requests - -from transloadit.client import Transloadit - - -def required_env(name): - value = os.environ.get(name) - if not value: - raise RuntimeError(f"{name} must be set") - return value - - -def fail(message): - raise RuntimeError(message) - - -def load_scenario(): - configured_path = os.environ.get("API2_SDK_EXAMPLE_SCENARIO") - scenario_path = ( - Path(configured_path) if configured_path else Path(__file__).with_name("api2-scenario.json") - ) - with scenario_path.open(encoding="utf-8") as scenario_file: - return json.load(scenario_file) - - -def response_data(response, operation): - data = response.data - if not isinstance(data, dict): - fail(f"{operation} returned non-JSON data: {data!r}") - if data.get("error"): - fail(f"{operation} returned {data.get('error')}: {data.get('message')}") - return data - - -def resolve_value(value_spec, context, label): - if not isinstance(value_spec, dict): - fail(f"{label} value spec must be an object") - if "value" in value_spec: - return value_spec["value"] - - source = value_spec.get("source") - if not isinstance(source, dict): - fail(f"{label} value spec has no literal value or source") - root = source.get("root") - if not isinstance(root, str) or root not in context: - fail(f"{label} value source root is unavailable") - current = context[root] - for part in source.get("path", []): - if not isinstance(current, dict) or part not in current: - fail(f"{label} value source cannot read {part}") - current = current[part] - return current - - -def scenario_bytes(upload): - source = upload.get("source") - if not isinstance(source, dict) or source.get("kind") != "bytes": - fail("upload.source.kind must be bytes") - if source.get("encoding") != "utf8": - fail("upload.source.encoding must be utf8") - return str(source["value"]).encode("utf-8") - - -def upload_metadata(upload, context): - metadata = {} - for field in upload.get("metadata", []): - metadata[field["name"]] = str(resolve_value(field["value"], context, field["name"])) - return metadata - - -def create_interrupted_upload(tus_url, content, metadata, stop_after_accepted_bytes): - """Create a TUS upload and only send the first chunk, leaving the upload - interrupted the way a dropped connection would.""" - metadata_parts = [] - for name, value in metadata.items(): - encoded_value = base64.b64encode(value.encode("utf-8")).decode("ascii") - metadata_parts.append(f"{name} {encoded_value}") - - create_response = requests.post( - tus_url, - data=b"", - headers={ - "Tus-Resumable": "1.0.0", - "Upload-Length": str(len(content)), - "Upload-Metadata": ",".join(metadata_parts), - }, - timeout=60, - ) - if create_response.status_code != 201: - fail(f"TUS create returned HTTP {create_response.status_code}, expected 201") - location = create_response.headers.get("Location") - if not location: - fail("TUS create did not return a Location header") - upload_url = urljoin(tus_url, location) - - patch_response = requests.patch( - upload_url, - data=content[:stop_after_accepted_bytes], - headers={ - "Tus-Resumable": "1.0.0", - "Upload-Offset": "0", - "Content-Type": "application/offset+octet-stream", - }, - timeout=60, - ) - if patch_response.status_code != 204: - fail(f"TUS first chunk returned HTTP {patch_response.status_code}, expected 204") - accepted_bytes = int(patch_response.headers.get("Upload-Offset", "-1")) - if accepted_bytes != stop_after_accepted_bytes: - fail( - f"TUS first chunk accepted {accepted_bytes} bytes, " - f"expected {stop_after_accepted_bytes}" - ) - - return upload_url - - -def write_result(result): - result_path = os.environ.get("API2_SDK_EXAMPLE_RESULT") - if not result_path: - return - - with Path(result_path).open("w", encoding="utf-8") as result_file: - json.dump(result, result_file, indent=2) - result_file.write("\n") - - -def main(): - scenario = load_scenario() - endpoint = required_env("TRANSLOADIT_ENDPOINT") - client = Transloadit( - auth_key=required_env("TRANSLOADIT_KEY"), - auth_secret=required_env("TRANSLOADIT_SECRET"), - service=endpoint, - ) - - create_response = scenario.get("prepared", {}).get("createResponse") - if not isinstance(create_response, dict): - fail("prepared.createResponse must be an object") - upload = scenario.get("upload") - if not isinstance(upload, dict): - fail("upload must be an object") - resume = upload.get("resume") - if not isinstance(resume, dict): - fail("upload.resume must be an object") - - context = {"createResponse": create_response, "scenario": scenario} - content = scenario_bytes(upload) - tus_url = str(resolve_value(upload["tusUrl"], context, "upload.tusUrl")) - metadata = upload_metadata(upload, context) - - first_upload_url = create_interrupted_upload( - tus_url, - content, - metadata, - resume["stopAfterAcceptedBytes"], - ) - - # Remember the interrupted upload by fingerprint, like a TUS client URL storage would. - stored_uploads = {resume["fingerprint"]: first_upload_url} - previous_upload_count = len(stored_uploads) - - completed_assembly = client.resume_tus_upload( - stored_uploads[resume["fingerprint"]], - content, - create_response["assembly_ssl_url"], - ) - response_data(completed_assembly, "resumeTusUpload") - - if resume["removeFingerprintOnSuccess"]: - del stored_uploads[resume["fingerprint"]] - remaining_previous_upload_count = len(stored_uploads) - - write_result( - { - "firstUploadUrl": first_upload_url, - "previousUploadCount": previous_upload_count, - "remainingPreviousUploadCount": remaining_previous_upload_count, - "uploadUrl": first_upload_url, - } - ) - - print( - "Python Transloadit SDK devdock scenario " - f"{scenario['exampleInput']['scenarioId']} resumed {first_upload_url}" - ) - - -if __name__ == "__main__": - main() diff --git a/examples/assembly_with_template.py b/examples/assembly_with_template.py index f76f59f..132ace3 100644 --- a/examples/assembly_with_template.py +++ b/examples/assembly_with_template.py @@ -25,7 +25,7 @@ def get_example_image_path(): def extract_template_id(response_data): - template_id = response_data.get("id") or response_data.get("template_id") + template_id = response_data.get("id") if not template_id: raise RuntimeError(f"Template response did not contain an id: {response_data}") return template_id @@ -35,7 +35,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url @@ -68,7 +68,7 @@ def main(): assembly.add_file(upload, "image") response = assembly.create(wait=True, resumable=False) - print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Assembly:", response.data["assembly_ssl_url"]) print("Template result:", first_result_url(response.data, "resize")) finally: client.delete_template(template_id) diff --git a/examples/async_image_resize.py b/examples/async_image_resize.py index 5b240e9..9c7d592 100644 --- a/examples/async_image_resize.py +++ b/examples/async_image_resize.py @@ -28,7 +28,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url @@ -54,7 +54,7 @@ async def main(): ) response = await assembly.create(wait=True, resumable=False) - print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Assembly:", response.data["assembly_ssl_url"]) print("Resized image:", first_result_url(response.data, "resize")) diff --git a/examples/async_template_lifecycle.py b/examples/async_template_lifecycle.py index db4f4e8..7dfa6f5 100644 --- a/examples/async_template_lifecycle.py +++ b/examples/async_template_lifecycle.py @@ -21,7 +21,7 @@ def get_credentials(): def extract_template_id(response_data): - template_id = response_data.get("id") or response_data.get("template_id") + template_id = response_data.get("id") if not template_id: raise RuntimeError(f"Template response did not contain an id: {response_data}") return template_id @@ -52,7 +52,7 @@ async def main(): print("Created template:", template_id) fetched = await client.get_template(template_id) - print("Fetched template:", fetched.data.get("name") or fetched.data.get("template_name")) + print("Fetched template:", fetched.data["name"]) updated = await client.update_template( template_id, diff --git a/examples/file_to_tts.py b/examples/file_to_tts.py index bfec770..c1f7ce8 100644 --- a/examples/file_to_tts.py +++ b/examples/file_to_tts.py @@ -40,7 +40,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url diff --git a/examples/image_resize.py b/examples/image_resize.py index 0bb91b0..06595f6 100644 --- a/examples/image_resize.py +++ b/examples/image_resize.py @@ -27,7 +27,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url @@ -53,7 +53,7 @@ def main(): ) response = assembly.create(wait=True, resumable=False) - print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Assembly:", response.data["assembly_ssl_url"]) print("Resized image:", first_result_url(response.data, "resize")) diff --git a/examples/resumable_upload.py b/examples/resumable_upload.py index 3a3e2f5..7ba8583 100644 --- a/examples/resumable_upload.py +++ b/examples/resumable_upload.py @@ -27,7 +27,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url @@ -53,7 +53,7 @@ def main(): ) response = assembly.create(wait=True, resumable=True) - print("Assembly:", response.data.get("assembly_ssl_url") or response.data.get("assembly_url")) + print("Assembly:", response.data["assembly_ssl_url"]) print("Resumable upload result:", first_result_url(response.data, "resize")) diff --git a/examples/template_lifecycle.py b/examples/template_lifecycle.py index 4b3b333..489e4c2 100644 --- a/examples/template_lifecycle.py +++ b/examples/template_lifecycle.py @@ -20,7 +20,7 @@ def get_credentials(): def extract_template_id(response_data): - template_id = response_data.get("id") or response_data.get("template_id") + template_id = response_data.get("id") if not template_id: raise RuntimeError(f"Template response did not contain an id: {response_data}") return template_id @@ -51,7 +51,7 @@ def main(): print("Created template:", template_id) fetched = client.get_template(template_id) - print("Fetched template:", fetched.data.get("name") or fetched.data.get("template_name")) + print("Fetched template:", fetched.data["name"]) updated = client.update_template( template_id, diff --git a/examples/video_translator.py b/examples/video_translator.py index a016b3e..94e3920 100644 --- a/examples/video_translator.py +++ b/examples/video_translator.py @@ -33,7 +33,7 @@ def first_result_url(response_data, step_name): results = (response_data.get("results") or {}).get(step_name) or [] if not results: raise RuntimeError(f"No results found for step {step_name!r}: {response_data}") - url = results[0].get("ssl_url") or results[0].get("url") + url = results[0].get("ssl_url") if not url: raise RuntimeError(f"No result URL found for step {step_name!r}: {response_data}") return url diff --git a/pyproject.toml b/pyproject.toml index 9a57a28..7c8c3f3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -37,11 +37,6 @@ Repository = "https://github.com/transloadit/python-sdk" Documentation = "https://transloadit.readthedocs.io" [tool.poetry] -include = [ - { path = "contracts", format = "sdist" }, - { path = "scripts/generate_endpoints.py", format = "sdist" }, - { path = "docs/api-coverage.md", format = "sdist" }, -] packages = [ { include = "transloadit" }, ] diff --git a/scripts/generate_endpoints.py b/scripts/generate_endpoints.py deleted file mode 100644 index 55b5e98..0000000 --- a/scripts/generate_endpoints.py +++ /dev/null @@ -1,219 +0,0 @@ -#!/usr/bin/env python3 -"""Generate SDK methods from the pinned, unmodified API2 public contract. - -No network or API2 checkout is needed for generation/checking. To update the pin, -pass --api2-root and --ref (a reviewed, committed producer revision). -""" -import argparse -import gzip -import hashlib -import json -from pathlib import Path -import pprint -import re -import subprocess - - -ROOT = Path(__file__).resolve().parents[1] -PIN = ROOT / "contracts/api2-contract.json.gz" -LOCK = ROOT / "contracts/api2-contract.lock.json" -START = " # " -END = " # " -# Python compatibility names only. HTTP facts always come from the contract. -NAMES = { - "create-template-credential": "create_template_credentials", - "get-template-credential": "get_template_credentials", - "update-template-credential": "update_template_credentials", - "delete-template-credential": "delete_template_credentials", - "options": "tus_options", -} -PARAMETERS = { - "templateIdOrName": "template_id", - "templateCredentialId": "identifier", -} - - -def snake(name): - return re.sub(r"(?", 1) - _, end = tail.split("", 1) - outputs[coverage] = start + "\n" + "\n".join(rows) + "\n" + end - return outputs - - -def main(): - parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--check", action="store_true") - parser.add_argument("--api2-root", type=Path) - parser.add_argument("--ref") - args = parser.parse_args() - if args.api2_root or args.ref: - if args.check or not (args.api2_root and args.ref): - parser.error("Pin updates require --api2-root and --ref, without --check") - revision = subprocess.check_output(["git", "-C", str(args.api2_root), "rev-parse", args.ref + "^{commit}"], text=True).strip() - source_path = "api2/generated/contracts/v1/contract.json" - raw = subprocess.check_output(["git", "-C", str(args.api2_root), "show", f"{revision}:{source_path}"]) - PIN.write_bytes(gzip.compress(raw, mtime=0)) - LOCK.write_text(json.dumps({"repository": "https://github.com/transloadit/api2", "revision": revision, "path": source_path, - "sha256": hashlib.sha256(raw).hexdigest()}, indent=2) + "\n", encoding="utf-8", newline="\n") - lock = json.loads(LOCK.read_text(encoding="utf-8")) - raw = gzip.decompress(PIN.read_bytes()) - if hashlib.sha256(raw).hexdigest() != lock["sha256"]: - raise SystemExit("Pinned API2 contract hash mismatch") - contract = json.loads(raw) - if contract["formatVersion"] != 1 or contract["format"] != "transloadit-public-dispatch-contract": - raise SystemExit("Unsupported API2 contract format") - stale = [] - for path, text in generate(contract, lock).items(): - expected = text.encode("utf-8") - if args.check: - if not path.exists() or path.read_bytes() != expected: - stale.append(str(path.relative_to(ROOT))) - else: - path.write_bytes(expected) - if stale: - raise SystemExit("Generated endpoints are stale: " + ", ".join(stale)) - print(f"{'Checked' if args.check else 'Generated'} {len(contract['apiReference']['operations'])} operations for sync and async clients") - - -if __name__ == "__main__": - main() diff --git a/tests/test_api_url.py b/tests/test_api_url.py index e15862c..4738760 100644 --- a/tests/test_api_url.py +++ b/tests/test_api_url.py @@ -4,7 +4,7 @@ class ApiUrlTest(unittest.TestCase): - def test_regional_signing_follows_contract_hosts_and_https_port(self): + def test_regional_signing_requires_api_hosts_and_https_port(self): service = "https://api2.transloadit.com" for host in ("api2-x.other.transloadit.com", "api2-xn--example.transloadit.com", "api2-morven.transloadit.com:8443"): with self.subTest(host=host): diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 202ddc1..1151420 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -127,7 +127,7 @@ async def handle_get_template(self, request): return web.json_response( { "ok": "TEMPLATE_FOUND", - "template_id": request.match_info["template_id"], + "id": request.match_info["template_id"], }, headers={"X-Async-Route": "get_template"}, ) @@ -137,7 +137,7 @@ async def handle_delete_template(self, request): return web.json_response( { "ok": "TEMPLATE_DELETED", - "template_id": request.match_info["template_id"], + "id": request.match_info["template_id"], }, headers={"X-Async-Route": "delete_template"}, ) @@ -145,7 +145,7 @@ async def handle_delete_template(self, request): async def handle_list_templates(self, request): self._record(request) return web.json_response( - {"items": [{"template_id": "tpl-1"}], "count": 1}, + {"items": [{"id": "tpl-1"}], "count": 1}, headers={"X-Async-Route": "list_templates"}, ) @@ -155,7 +155,7 @@ async def handle_update_template(self, request): return web.json_response( { "ok": "TEMPLATE_UPDATED", - "template_id": request.match_info["template_id"], + "id": request.match_info["template_id"], }, headers={"X-Async-Route": "update_template"}, ) @@ -167,7 +167,9 @@ async def handle_create_template(self, request): return web.json_response( { "ok": "TEMPLATE_CREATED", - "template_name": params["name"], + "id": "tpl-created", + "name": params["name"], + "content": params["template"], }, headers={"X-Async-Route": "create_template"}, ) @@ -287,18 +289,6 @@ async def asyncTearDown(self): await self.server.close() - async def test_issue_bearer_token_rejects_127_prefixed_domain(self): - session = _RecordingSession({}) - client = AsyncTransloadit( - "key", - "secret", - service="http://127.attacker.com", - session=session, - ) - - with self.assertRaisesRegex(ValueError, "insecure bearer token endpoint"): - await client.issue_bearer_token() - self.assertEqual(session.calls, []) async def test_async_client_methods_and_context_manager(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: @@ -320,21 +310,21 @@ async def test_async_client_methods_and_context_manager(self): response = await client.get_template("tpl-1") self.assertEqual(response.data["ok"], "TEMPLATE_FOUND") - self.assertEqual(response.data["template_id"], "tpl-1") + self.assertEqual(response.data["id"], "tpl-1") response = await client.list_templates() - self.assertEqual(response.data["items"], [{"template_id": "tpl-1"}]) + self.assertEqual(response.data["items"], [{"id": "tpl-1"}]) self.assertEqual(response.data["count"], 1) response = await client.update_template("tpl-1", {"name": "foo_bar"}) self.assertEqual(response.data["ok"], "TEMPLATE_UPDATED") - self.assertEqual(response.data["template_id"], "tpl-1") + self.assertEqual(response.data["id"], "tpl-1") template = client.new_template("foo") template.add_step("resize", "/image/resize", {"width": 70, "height": 70}) response = await template.create() self.assertEqual(response.data["ok"], "TEMPLATE_CREATED") - self.assertEqual(response.data["template_name"], "foo") + self.assertEqual(response.data["name"], "foo") self.assertIsNone(client.request.session) @@ -409,10 +399,9 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): with mock.patch.object(transloadit_client.request, "public", new_callable=mock.AsyncMock) as request_mock: await transloadit_client.get_assembly( assembly_url="https://api2-region.transloadit.com/assemblies/abc123", - params={"nonce": 123}, ) request_mock.assert_awaited_once_with( - "GET", "https://api2-region.transloadit.com/assemblies/abc123", params={"nonce": 123} + "GET", "https://api2-region.transloadit.com/assemblies/abc123", params=None ) self.assertEqual(transloadit_session.calls, []) @@ -472,109 +461,7 @@ async def test_async_client_rejects_invalid_template_ids(self): self.assertEqual(session.calls, []) - async def test_async_generated_endpoint_methods_call_request_helpers(self): - client = AsyncTransloadit("key", "secret", service=self.server.base_url) - response = Response(data={"ok": "OK"}, status_code=200, headers={}) - assembly_data = {"steps": {":original": {"robot": "/upload/handle"}}} - extra_data = {"field": "value"} - files = {"file": io.BytesIO(b"payload")} - replay_data = {"wait": True} - credential_data = {"name": "demo", "type": "s3", "content": {}} - - get_mock = mock.AsyncMock(return_value=response) - post_mock = mock.AsyncMock(return_value=response) - put_mock = mock.AsyncMock(return_value=response) - delete_mock = mock.AsyncMock(return_value=response) - - with mock.patch.object(client.request, "get", new=get_mock): - with mock.patch.object(client.request, "post", new=post_mock): - with mock.patch.object(client.request, "put", new=put_mock): - with mock.patch.object(client.request, "delete", new=delete_mock): - await client.create_assembly(assembly_data, extra_data, files) - await client.create_assembly_with_id( - "assembly/with?chars", assembly_data, extra_data, files - ) - await client.replay_assembly("assembly/with?chars", replay_data) - await client.replay_assembly_notification( - "assembly/with?chars", replay_data - ) - await client.create_template({"name": "template"}) - await client.validate_template_credential_oauth_on_create( - {"type": "dropbox"} - ) - await client.create_template_credentials(credential_data) - await client.get_builtin_template("builtin/with?chars") - await client.get_template_full("template/with?chars") - await client.get_builtin_template_full("builtin/full?chars") - await client.list_priority_job_slots() - await client.list_template_credentials() - await client.list_template_credential_types() - await client.get_template_credentials("cred/with?chars") - await client.update_template_credentials("cred/with?chars", credential_data) - await client.delete_template_credentials("cred/with?chars") - - self.assertEqual( - post_mock.await_args_list, - [ - mock.call( - "/assemblies", - data=assembly_data, - extra_data=extra_data, - files=files, - ), - mock.call( - "/assemblies/assembly%2Fwith%3Fchars", - data=assembly_data, - extra_data=extra_data, - files=files, - ), - mock.call("/assemblies/assembly%2Fwith%3Fchars/replay", data=replay_data), - mock.call( - "/assembly_notifications/assembly%2Fwith%3Fchars/replay", - data=replay_data, - ), - mock.call("/templates", data={"name": "template"}), - mock.call("/template_credentials/validateOauthOnCreate", data={"type": "dropbox"}), - mock.call("/template_credentials", data=credential_data), - ], - ) - self.assertEqual( - get_mock.await_args_list, - [ - mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), - mock.call("/templates/template%2Fwith%3Fchars/full", params=None), - mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), - mock.call("/queues/job_slots", params=None), - mock.call("/template_credentials", params=None), - mock.call("/template_credentials/types", params=None), - mock.call("/template_credentials/cred%2Fwith%3Fchars", params=None), - ], - ) - put_mock.assert_awaited_once_with( - "/template_credentials/cred%2Fwith%3Fchars", data=credential_data - ) - delete_mock.assert_awaited_once_with( - "/template_credentials/cred%2Fwith%3Fchars", data=None - ) - async def test_async_generated_endpoint_methods_reject_empty_path_ids(self): - client = AsyncTransloadit("key", "secret", service=self.server.base_url) - methods = [ - client.create_assembly_with_id, - client.replay_assembly, - client.replay_assembly_notification, - client.list_assembly_notifications, - client.get_builtin_template, - client.get_template_full, - client.get_builtin_template_full, - client.get_template_credentials, - client.delete_template_credentials, - client.update_template_credentials, - ] - - for method in methods: - with self.assertRaises(ValueError): - await method("") async def test_async_client_close_reopens_owned_session(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) @@ -622,7 +509,7 @@ async def test_async_client_delete_template_get_bill_and_plain_text_fallback(sel async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.delete_template("tpl-1") self.assertEqual(response.data["ok"], "TEMPLATE_DELETED") - self.assertEqual(response.data["template_id"], "tpl-1") + self.assertEqual(response.data["id"], "tpl-1") self.assertEqual(response.headers["X-Async-Route"], "delete_template") response = await client.get_bill(9, 2017) @@ -767,74 +654,8 @@ async def test_async_assembly_wait_raises_on_plain_text_success_poll_response(se ) sleep_mock.assert_awaited_once_with(0) - async def test_async_wait_for_assembly_polls_until_terminal(self): - responses = [ - Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), - Response(data={"ok": "ASSEMBLY_EXECUTING"}, status_code=200), - Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200), - ] - assembly_url = f"{self.server.base_url}/assemblies/assembly-123" - - async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: - with mock.patch.object( - client, - "get_assembly", - new=mock.AsyncMock(side_effect=responses), - ) as get_mock: - with mock.patch( - "transloadit.async_client.asyncio.sleep", - new_callable=mock.AsyncMock, - ) as sleep_mock: - response = await client.wait_for_assembly(assembly_url) - self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") - self.assertEqual( - get_mock.await_args_list, - [ - mock.call(assembly_url=assembly_url), - mock.call(assembly_url=assembly_url), - mock.call(assembly_url=assembly_url), - ], - ) - self.assertEqual(sleep_mock.await_args_list, [mock.call(1), mock.call(1)]) - async def test_async_wait_for_assembly_rejects_non_json_poll_response(self): - async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: - with mock.patch.object( - client, - "get_assembly", - new=mock.AsyncMock(return_value=Response(data="plain response", status_code=502)), - ): - with self.assertRaises(RuntimeError): - await client.wait_for_assembly( - f"{self.server.base_url}/assemblies/assembly-123" - ) - - async def test_async_create_tus_assembly_uses_contract_payload(self): - expected_response = Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200) - - async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: - with mock.patch.object( - client, - "create_assembly", - new=mock.AsyncMock(return_value=expected_response), - ) as create_mock: - response = await client.create_tus_assembly(2) - - self.assertIs(response, expected_response) - create_mock.assert_awaited_once_with( - data={ - "await": False, - "steps": { - ":original": { - "output_meta": True, - "result": "debug", - "robot": "/upload/handle", - }, - }, - }, - extra_data={"num_expected_upload_files": 2}, - ) def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") diff --git a/tests/test_client.py b/tests/test_client.py index 4286f3c..b2f2f47 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -86,102 +86,15 @@ def test_assembly_urls_are_trusted_and_unauthenticated(self): request_mock.assert_not_called() self.transloadit.get_assembly( assembly_url="https://api2-region.transloadit.com/assemblies/abc123", - params={"nonce": 123}, ) request_mock.assert_called_once_with( - "GET", "https://api2-region.transloadit.com/assemblies/abc123", params={"nonce": 123} + "GET", "https://api2-region.transloadit.com/assemblies/abc123", params=None ) - @requests_mock.Mocker() - def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self, requests_mock): - requests_mock.post( - f"{self.transloadit.service}/token", - json={ - "access_token": "abc", - "expires_in": 21600, - "scope": "assemblies:read", - "token_type": "Bearer", - }, - ) - response = self.transloadit.issue_bearer_token({"scope": "assemblies:read"}) - self.assertEqual(response.data["access_token"], "abc") - request = requests_mock.request_history[0] - self.assertEqual(request.headers["Authorization"], "Basic a2V5OnNlY3JldA==") - self.assertEqual( - request.headers["Content-Type"], - "application/x-www-form-urlencoded", - ) - self.assertEqual( - urllib.parse.parse_qs(request.text), - { - "grant_type": ["client_credentials"], - "scope": ["assemblies:read"], - }, - ) - def test_issue_bearer_token_rejects_127_prefixed_domain(self): - client = Transloadit("key", "secret", service="http://127.attacker.com") - with mock.patch("transloadit.client.requests.post") as post_mock: - with self.assertRaisesRegex(ValueError, "insecure bearer token endpoint"): - client.issue_bearer_token() - post_mock.assert_not_called() - - def test_wait_for_assembly_polls_until_terminal(self): - responses = [ - Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200), - Response(data={"ok": "ASSEMBLY_EXECUTING"}, status_code=200), - Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200), - ] - assembly_url = "https://api2.example/assemblies/assembly-123" - - with mock.patch.object(self.transloadit, "get_assembly", side_effect=responses) as get_mock: - with mock.patch("transloadit.client.sleep") as sleep_mock: - response = self.transloadit.wait_for_assembly(assembly_url) - self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") - self.assertEqual( - get_mock.call_args_list, - [ - mock.call(assembly_url=assembly_url), - mock.call(assembly_url=assembly_url), - mock.call(assembly_url=assembly_url), - ], - ) - self.assertEqual(sleep_mock.call_args_list, [mock.call(1), mock.call(1)]) - - def test_wait_for_assembly_rejects_non_json_poll_response(self): - with mock.patch.object( - self.transloadit, - "get_assembly", - return_value=Response(data="plain response", status_code=502), - ): - with self.assertRaises(RuntimeError): - self.transloadit.wait_for_assembly("https://api2.example/assemblies/assembly-123") - - def test_create_tus_assembly_uses_contract_payload(self): - expected_response = Response(data={"ok": "ASSEMBLY_UPLOADING"}, status_code=200) - - with mock.patch.object( - self.transloadit, "create_assembly", return_value=expected_response - ) as create_mock: - response = self.transloadit.create_tus_assembly(2) - - self.assertIs(response, expected_response) - create_mock.assert_called_once_with( - data={ - "await": False, - "steps": { - ":original": { - "output_meta": True, - "result": "debug", - "robot": "/upload/handle", - }, - }, - }, - extra_data={"num_expected_upload_files": 2}, - ) def test_quotes_path_ids(self): with mock.patch.object(self.transloadit, '_request_assembly_url') as assembly_mock: @@ -191,11 +104,11 @@ def test_quotes_path_ids(self): self.assertEqual( get_mock.call_args_list, - [mock.call('/templates/template%2Fwith%3Fchars', params=None)], + [mock.call('/templates/template%2Fwith%3Fchars')], ) self.assertEqual( assembly_mock.call_args_list, - [mock.call('/assemblies/assembly%2Fwith%3Fchars', 'GET', params=None)], + [mock.call('/assemblies/assembly%2Fwith%3Fchars', 'GET')], ) def test_rejects_invalid_template_ids(self): @@ -215,101 +128,7 @@ def test_rejects_invalid_template_ids(self): with self.assertRaises(ValueError): self.transloadit.delete_template(template_id) - def test_generated_endpoint_methods_call_request_helpers(self): - assembly_data = {"steps": {":original": {"robot": "/upload/handle"}}} - extra_data = {"field": "value"} - files = {"file": object()} - replay_data = {"wait": True} - credential_data = {"name": "demo", "type": "s3", "content": {}} - - with mock.patch.object(self.transloadit.request, "get") as get_mock: - with mock.patch.object(self.transloadit.request, "post") as post_mock: - with mock.patch.object(self.transloadit.request, "put") as put_mock: - with mock.patch.object(self.transloadit.request, "delete") as delete_mock: - self.transloadit.create_assembly(assembly_data, extra_data, files) - self.transloadit.create_assembly_with_id( - "assembly/with?chars", assembly_data, extra_data, files - ) - self.transloadit.replay_assembly("assembly/with?chars", replay_data) - self.transloadit.replay_assembly_notification( - "assembly/with?chars", replay_data - ) - self.transloadit.create_template({"name": "template"}) - self.transloadit.validate_template_credential_oauth_on_create( - {"type": "dropbox"} - ) - self.transloadit.create_template_credentials(credential_data) - self.transloadit.get_builtin_template("builtin/with?chars") - self.transloadit.get_template_full("template/with?chars") - self.transloadit.get_builtin_template_full("builtin/full?chars") - self.transloadit.list_priority_job_slots() - self.transloadit.list_template_credentials() - self.transloadit.list_template_credential_types() - self.transloadit.get_template_credentials("cred/with?chars") - self.transloadit.update_template_credentials( - "cred/with?chars", credential_data - ) - self.transloadit.delete_template_credentials("cred/with?chars") - self.assertEqual( - post_mock.call_args_list, - [ - mock.call( - "/assemblies", - data=assembly_data, - extra_data=extra_data, - files=files, - ), - mock.call( - "/assemblies/assembly%2Fwith%3Fchars", - data=assembly_data, - extra_data=extra_data, - files=files, - ), - mock.call("/assemblies/assembly%2Fwith%3Fchars/replay", data=replay_data), - mock.call( - "/assembly_notifications/assembly%2Fwith%3Fchars/replay", - data=replay_data, - ), - mock.call("/templates", data={"name": "template"}), - mock.call("/template_credentials/validateOauthOnCreate", data={"type": "dropbox"}), - mock.call("/template_credentials", data=credential_data), - ], - ) - self.assertEqual( - get_mock.call_args_list, - [ - mock.call("/templates/builtin/builtin%2Fwith%3Fchars", params=None), - mock.call("/templates/template%2Fwith%3Fchars/full", params=None), - mock.call("/templates/builtin/builtin%2Ffull%3Fchars/full", params=None), - mock.call("/queues/job_slots", params=None), - mock.call("/template_credentials", params=None), - mock.call("/template_credentials/types", params=None), - mock.call("/template_credentials/cred%2Fwith%3Fchars", params=None), - ], - ) - put_mock.assert_called_once_with( - "/template_credentials/cred%2Fwith%3Fchars", data=credential_data - ) - delete_mock.assert_called_once_with("/template_credentials/cred%2Fwith%3Fchars", data=None) - - def test_generated_endpoint_methods_reject_empty_path_ids(self): - methods = [ - self.transloadit.create_assembly_with_id, - self.transloadit.replay_assembly, - self.transloadit.replay_assembly_notification, - self.transloadit.list_assembly_notifications, - self.transloadit.get_builtin_template, - self.transloadit.get_template_full, - self.transloadit.get_builtin_template_full, - self.transloadit.get_template_credentials, - self.transloadit.delete_template_credentials, - self.transloadit.update_template_credentials, - ] - - for method in methods: - with self.assertRaises(ValueError): - method("") @requests_mock.Mocker() def test_list_assemblies(self, mock): @@ -336,11 +155,11 @@ def test_cancel_assembly(self, mock): def test_get_template(self, mock): id_ = "abcdef12345" url = f"{self.transloadit.service}/templates/{id_}" - mock.get(url, text='{"ok": "TEMPLATE_FOUND", "template_id": "abcdef12345"}') + mock.get(url, text='{"ok": "TEMPLATE_FOUND", "id": "abcdef12345"}') response = self.transloadit.get_template(id_) self.assertEqual(response.data["ok"], "TEMPLATE_FOUND") - self.assertEqual(response.data["template_id"], "abcdef12345") + self.assertEqual(response.data["id"], "abcdef12345") @requests_mock.Mocker() def test_list_templates(self, mock): @@ -358,13 +177,13 @@ def test_update_template(self, mock): sub_body = '"name": "foo_bar"' mock.put( url, - text='{"ok": "TEMPLATE_UPDATED", "template_id": "abcdef12345"}', + text='{"ok": "TEMPLATE_UPDATED", "id": "abcdef12345"}', additional_matcher=request_body_matcher(urllib.parse.quote_plus(sub_body)), ) response = self.transloadit.update_template(id_, {"name": "foo_bar"}) self.assertEqual(response.data["ok"], "TEMPLATE_UPDATED") - self.assertEqual(response.data["template_id"], "abcdef12345") + self.assertEqual(response.data["id"], "abcdef12345") @requests_mock.Mocker() def test_delete_tempalte(self, mock): diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py deleted file mode 100644 index e55a887..0000000 --- a/tests/test_contract_endpoints.py +++ /dev/null @@ -1,803 +0,0 @@ -import json -import asyncio -import base64 -import hashlib -import hmac -import io -import subprocess -import sys -from contextlib import asynccontextmanager -from pathlib import Path -from urllib.parse import parse_qs -from unittest import mock - -import aiohttp -from aiohttp import web -import pytest -from requests.structures import CaseInsensitiveDict - -from transloadit.client import Transloadit -from transloadit.async_client import AsyncTransloadit -from transloadit.stream import EventParser, StreamError -from transloadit.endpoint_transport import tus_request, validate_upload_location -from transloadit.response import Response - - -def test_create_auth_key_sends_signed_request(requests_mock): - endpoint = requests_mock.post( - "https://api2.transloadit.com/auth_keys", json={"ok": "AUTH_KEY_CREATED"} - ) - client = Transloadit("key", "secret") - response = client.create_auth_key({"description": "worker", "scope": "assemblies:read"}) - payload = parse_qs(endpoint.last_request.text) - params = json.loads(payload["params"][0]) - assert params["description"] == "worker" - assert params["scope"] == "assemblies:read" - assert params["auth"]["key"] == "key" - assert payload["signature"][0].startswith("sha384:") - assert response.data == {"ok": "AUTH_KEY_CREATED"} - - -def test_move_dam_asset_uses_patch(requests_mock): - endpoint = requests_mock.patch( - "https://api2.transloadit.com/dam/assets/asset-123", json={"ok": "ASSET_MOVED"} - ) - response = Transloadit("key", "secret").move_dam_asset("asset-123", {"filename": "new.jpg"}) - assert endpoint.call_count == 1 - assert response.data["ok"] == "ASSET_MOVED" - - -def test_unsigned_put_can_send_extra_fields(requests_mock): - endpoint = requests_mock.put("https://other.example/upload", json={"ok": "OK"}) - Transloadit("key", "secret").request.put("https://other.example/upload", extra_data={"field": "value"}) - assert parse_qs(endpoint.last_request.text) == {"field": ["value"]} - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_polling_retries_rate_limits_and_stops_after_retry_budget(mode): - async def scenario(): - cls = Transloadit if mode == "sync" else AsyncTransloadit - client = cls("key", "secret") - limited = Response(data={"error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", "info": {"retryIn": .125}}, status_code=429) - completed = Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200) - make_mock = mock.Mock if mode == "sync" else mock.AsyncMock - sleep_path = "transloadit.client.sleep" if mode == "sync" else "transloadit.async_client.asyncio.sleep" - with mock.patch(sleep_path, new_callable=make_mock) as sleep: - client.get_assembly = make_mock(side_effect=[limited, completed]) - result = await call(client, "wait_for_assembly", "https://api2.transloadit.com/assemblies/" + ASSEMBLY_ID) - assert result is completed - sleep.assert_called_once_with(.125) - client.get_assembly = make_mock(return_value=limited) - result = await call(client, "wait_for_assembly", "https://api2.transloadit.com/assemblies/" + ASSEMBLY_ID, retries=2) - assert result is limited and client.get_assembly.call_count == 3 - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_high_level_upload_preserves_assembly_errors(mode): - async def scenario(): - client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") - make_mock = mock.Mock if mode == "sync" else mock.AsyncMock - client.create_tus_assembly = make_mock(return_value=Response(data={"error": "INVALID_AUTH_KEY"}, status_code=401)) - client.create_upload = make_mock() - with pytest.raises(RuntimeError, match="INVALID_AUTH_KEY.*401"): - await call(client, "upload_tus_assembly", b"file", "file", "file.txt") - client.create_upload.assert_not_called() - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("key", ["", "two words", "a,b", "a\r\nb", "caf\u00e9"]) -def test_high_level_upload_rejects_invalid_metadata_before_creating_assembly(mode, key): - async def scenario(): - client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") - client.create_tus_assembly = (mock.Mock if mode == "sync" else mock.AsyncMock)() - with pytest.raises(ValueError, match="metadata"): - await call(client, "upload_tus_assembly", b"file", "file", "file.txt", user_meta={key: "value"}) - client.create_tus_assembly.assert_not_called() - asyncio.run(scenario()) - - -@pytest.mark.parametrize("header", ["Upload-Concat", "X-HTTP-Method-Override", "x-method-override"]) -def test_raw_tus_rejects_contract_unsupported_headers(header): - client = Transloadit("key", "secret") - with pytest.raises(ValueError, match="Unsupported TUS header"): - tus_request(client, "tusd.get-upload-offset", "https://api2.transloadit.com/resumable/files/upload", {header: "DELETE"}, None) - - -def test_sync_isolated_transport_preserves_proxy_and_ca_settings(requests_mock, monkeypatch, tmp_path): - url = "https://api2.transloadit.com/assembly_notifications" - endpoint = requests_mock.get(url, json={"ok": "OK"}) - monkeypatch.delenv("https_proxy", raising=False) - monkeypatch.setenv("HTTPS_PROXY", "http://proxy.invalid:3128") - monkeypatch.delenv("no_proxy", raising=False) - monkeypatch.setenv("NO_PROXY", "") - monkeypatch.setenv("REQUESTS_CA_BUNDLE", "/custom/company-ca.pem") - netrc = tmp_path / "netrc" - netrc.write_text("machine api2.transloadit.com login ambient password must-not-leak\n") - monkeypatch.setenv("NETRC", str(netrc)) - Transloadit("key", "secret", bearer_token="must-not-leak").request.public("GET", "/assembly_notifications") - assert endpoint.last_request.proxies["https"] == "http://proxy.invalid:3128" - assert endpoint.last_request.verify == "/custom/company-ca.pem" - assert "Authorization" not in endpoint.last_request.headers - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_isolated_transports_use_environment_proxy_without_netrc(mode, monkeypatch, tmp_path): - async def scenario(): - async with wire_client(mode) as (client, server): - monkeypatch.delenv("http_proxy", raising=False) - monkeypatch.setenv("HTTP_PROXY", server.url) - monkeypatch.delenv("no_proxy", raising=False) - monkeypatch.setenv("NO_PROXY", "") - netrc = tmp_path / "netrc" - netrc.write_text("machine 127.0.0.2 login ambient password must-not-leak\n") - monkeypatch.setenv("NETRC", str(netrc)) - # No server listens here: every request must traverse the proxy. - client.service = "http://127.0.0.2:1" - await call(client, "list_assembly_notifications", ASSEMBLY_ID) - await call(client, "issue_bearer_token", {"grant_type": "refresh_token", "refresh_token": "refresh"}) - assembly = {"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": client.service + "/assemblies/" + ASSEMBLY_ID, - "tus_url": client.service + "/resumable/files"} - await call(client, "tus_options", assembly) - stream_url = client.service + "/ws1?assembly=" + ASSEMBLY_ID - if mode == "sync": - def consume(): - with client.stream_assembly_status(stream_url) as events: - return list(events) - await asyncio.to_thread(consume) - else: - async with client.stream_assembly_status(stream_url) as events: - assert [event async for event in events][-1].terminal - assert len(server.requests) == 4 - assert all("Authorization" not in request["headers"] for request in server.requests) - asyncio.run(scenario()) - - -def test_async_isolated_transport_reuses_injected_connector_without_credentials(monkeypatch): - monkeypatch.delenv("no_proxy", raising=False) - monkeypatch.setenv("NO_PROXY", "sdk.invalid") - async def scenario(): - async with wire_client("async") as (_, server): - class Resolver(aiohttp.abc.AbstractResolver): - async def resolve(self, host, port=0, family=0): - return [{"hostname": host, "host": "127.0.0.1", "port": port, "family": 2, "proto": 0, "flags": 0}] - async def close(self): - pass - connector = aiohttp.TCPConnector(resolver=Resolver()) - async with aiohttp.ClientSession(connector=connector, auth=aiohttp.BasicAuth("ambient", "secret"), - headers={"Cookie": "session=must-not-leak"}) as session: - service = server.url.replace("127.0.0.1", "sdk.invalid") - async with AsyncTransloadit("key", "secret", service=service, session=session) as client: - await client.list_assembly_notifications(ASSEMBLY_ID) - assert not connector.closed and not session.closed - assert "Authorization" not in server.requests[-1]["headers"] - assert "Cookie" not in server.requests[-1]["headers"] - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_high_level_raw_tus_upload_and_resume(mode): - async def scenario(): - async with wire_client(mode) as (client, server): - assembly_url = server.url + "/assemblies/" + ASSEMBLY_ID - created = Response(data={"ok": "ASSEMBLY_UPLOADING", "assembly_id": ASSEMBLY_ID, - "assembly_ssl_url": assembly_url, "tus_url": server.url + "/resumable/files"}, - status_code=200) - client.create_tus_assembly = (mock.Mock if mode == "sync" else mock.AsyncMock)(return_value=created) - content = b"abcdef" - completed, upload_url = await call(client, "upload_tus_assembly", content, "file", "test.txt", {"label": "caf\u00e9"}) - assert server.upload == content and completed.status_code == 200 - metadata = dict(part.split(" ", 1) for part in server.requests[0]["headers"]["Upload-Metadata"].split(",")) - assert base64.b64decode(metadata["label"]).decode() == "caf\u00e9" - assert base64.b64decode(metadata["assembly_url"]).decode() == assembly_url - server.upload = content[:3] - completed = await call(client, "resume_tus_upload", upload_url, content, assembly_url) - assert server.upload == content and completed.status_code == 200 - assert server.requests[-2]["headers"]["Upload-Offset"] == "3" - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_explicit_bearer_wins_over_netrc_for_every_http_method(mode, monkeypatch, tmp_path): - netrc = tmp_path / "netrc" - netrc.write_text("machine 127.0.0.1 login ambient password must-not-leak\n") - monkeypatch.setenv("NETRC", str(netrc)) - async def scenario(): - async with wire_client(mode, bearer_token="selected-token") as (client, server): - await call(client, "list_auth_keys") - await call(client, "create_auth_key", {"description": "test"}) - await call(client, "update_auth_key", "key-id", {"description": "updated"}) - await call(client, "move_dam_asset", "asset-id", {"filename": "updated"}) - await call(client, "delete_auth_key", "key-id") - assert {request["method"] for request in server.requests} == {"GET", "POST", "PUT", "PATCH", "DELETE"} - assert all(request["headers"]["Authorization"] == "Bearer selected-token" for request in server.requests) - asyncio.run(scenario()) - - -def test_bearer_ignores_injected_session_account_credentials(): - async def scenario(): - async with wire_client("async") as (_, server): - async with aiohttp.ClientSession(auth=aiohttp.BasicAuth("ambient", "secret"), - headers={"Cookie": "ambient-cookie"}) as session: - client = AsyncTransloadit("key", None, service=server.url, session=session, bearer_token="selected-token") - await client.list_auth_keys() - assert server.requests[-1]["headers"]["Authorization"] == "Bearer selected-token" - assert "Cookie" not in server.requests[-1]["headers"] - assert not session.closed - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_assembly_capabilities_do_not_borrow_account_credentials(mode, monkeypatch, tmp_path): - netrc = tmp_path / "netrc" - netrc.write_text("machine 127.0.0.1 login ambient password must-not-leak\n") - monkeypatch.setenv("NETRC", str(netrc)) - async def scenario(): - async with wire_client(mode, bearer_token="must-not-leak") as (client, server): - async with aiohttp.ClientSession(auth=aiohttp.BasicAuth("ambient", "secret"), - headers={"Cookie": "ambient-cookie"}) as session: - if mode == "async": - client = AsyncTransloadit("key", "secret", service=server.url, session=session, bearer_token="must-not-leak") - await call(client, "get_assembly", assembly_id=ASSEMBLY_ID) - await call(client, "cancel_assembly", assembly_url=server.url + "/assemblies/" + ASSEMBLY_ID) - assert len(server.requests) == 2 - for request in server.requests: - assert "Authorization" not in request["headers"] - assert "Cookie" not in request["headers"] - assert request["query"] == {} - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("encoding,line_ending", [("utf-8", "\n"), ("utf-8", "\r\n"), ("utf-16", "\n")]) -def test_text_mode_multipart_preserves_content_and_file_ownership(mode, tmp_path, encoding, line_ending): - path = tmp_path / "text.txt" - path.write_bytes(("caf\u00e9" + line_ending).encode(encoding)) - async def scenario(): - async with wire_client(mode) as (client, server): - if mode == "async": - client.request._timeout = lambda: aiohttp.ClientTimeout(total=5) - assembly = client.new_assembly() - with path.open(encoding=encoding) as upload: - assembly.add_file(upload, "text") - if mode == "sync": - await asyncio.to_thread(assembly.create, resumable=False) - else: - await assembly.create(resumable=False) - assert not upload.closed - assert server.requests[-1]["fields"]["text"] == "caf\u00e9\n".encode() - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_custom_service_can_poll_returned_worker_origin(mode): - async def scenario(): - async with wire_client(mode) as (client, server), wire_client(mode) as (_, worker): - server.assembly_response = {"ok": "ASSEMBLY_UPLOADING", "assembly_id": ASSEMBLY_ID, - "assembly_ssl_url": worker.url + "/assemblies/" + ASSEMBLY_ID} - assembly = client.new_assembly() - sleep_path = "transloadit.assembly.sleep" if mode == "sync" else "transloadit.async_assembly.asyncio.sleep" - with mock.patch(sleep_path, new_callable=mock.Mock if mode == "sync" else mock.AsyncMock): - if mode == "sync": - result = await asyncio.to_thread(assembly.create, wait=True) - else: - result = await assembly.create(wait=True) - assert result.data["ok"] == "ASSEMBLY_COMPLETED" - assert "Authorization" not in worker.requests[-1]["headers"] - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_polling_continues_through_replaying_assemblies(mode): - async def scenario(): - client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") - make_mock = mock.Mock if mode == "sync" else mock.AsyncMock - completed = Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200) - client.get_assembly = make_mock(side_effect=[Response(data={"ok": "ASSEMBLY_REPLAYING"}, status_code=200), completed]) - sleep_path = "transloadit.client.sleep" if mode == "sync" else "transloadit.async_client.asyncio.sleep" - with mock.patch(sleep_path, new_callable=make_mock): - assert await call(client, "wait_for_assembly", "assembly") is completed - assert client.get_assembly.call_count == 2 - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("host", ["api2.transloadit.com", "api2-morven.transloadit.com"]) -def test_legacy_http_assembly_urls_use_https(mode, host): - async def scenario(): - client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") - client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() - for method, verb in [("get_assembly", "GET"), ("cancel_assembly", "DELETE")]: - await call(client, method, assembly_url=f"http://{host}/assemblies/{ASSEMBLY_ID}") - client.request.public.assert_called_with(verb, f"https://{host}/assemblies/{ASSEMBLY_ID}", params=None) - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("host", ["api2-x.other.transloadit.com", "api2-xn--example.transloadit.com"]) -def test_assembly_urls_use_contract_host_pattern(mode, host): - async def scenario(): - client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") - client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() - with pytest.raises(ValueError, match="untrusted Assembly URL"): - await call(client, "get_assembly", assembly_url=f"https://{host}/assemblies/{ASSEMBLY_ID}") - client.request.public.assert_not_called() - asyncio.run(scenario()) - - -@pytest.mark.parametrize("trust_env", [False, True]) -def test_isolated_async_calls_preserve_explicit_proxy_configuration(monkeypatch, trust_env): - # The injected proxy takes precedence over an unusable environment proxy. - monkeypatch.delenv("http_proxy", raising=False) - monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.3:1") - monkeypatch.delenv("no_proxy", raising=False) - monkeypatch.setenv("NO_PROXY", "") - async def scenario(): - async with wire_client("async") as (_, server): - proxy_auth = aiohttp.BasicAuth("proxy-user", "proxy-password") - async with aiohttp.ClientSession(proxy=server.url, proxy_auth=proxy_auth, trust_env=trust_env) as session: - service = "http://127.0.0.2:1" - client = AsyncTransloadit("key", "secret", service=service, session=session, bearer_token="selected-token") - await client.list_auth_keys() - await client.get_assembly(assembly_id=ASSEMBLY_ID) - await client.list_assembly_notifications(ASSEMBLY_ID) - await client.issue_bearer_token({"grant_type": "refresh_token", "refresh_token": "refresh"}) - await client.tus_options({"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": service + "/assemblies/" + ASSEMBLY_ID, - "tus_url": service + "/resumable/files"}) - async with client.stream_assembly_status(service + "/ws1?assembly=" + ASSEMBLY_ID) as events: - assert [event async for event in events][-1].terminal - assert not session.closed - assert len(server.requests) == 6 - assert all(request["headers"]["Proxy-Authorization"] == proxy_auth.encode() for request in server.requests) - assert server.requests[0]["headers"]["Authorization"] == "Bearer selected-token" - assert all("Authorization" not in request["headers"] for request in server.requests[1:]) - asyncio.run(scenario()) - - -def test_async_proxy_selection_matches_signed_calls_with_all_proxy(monkeypatch): - for name in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "no_proxy"): - monkeypatch.delenv(name, raising=False) - monkeypatch.setenv("ALL_PROXY", "socks5://127.0.0.2:1") - monkeypatch.setenv("NO_PROXY", "") - async def scenario(): - async with wire_client("async") as (client, server): - await client.list_templates() - await client.get_assembly(assembly_id=ASSEMBLY_ID) - client.bearer_token = "selected-token" - await client.list_templates() - assert len(server.requests) == 3 - asyncio.run(scenario()) - - -def test_async_environment_proxy_preserves_proxy_netrc_only(monkeypatch, tmp_path): - netrc = tmp_path / "netrc" - netrc.write_text("machine 127.0.0.1 login proxy-user password proxy-password\nmachine 127.0.0.2 login origin-user password must-not-leak\n") - monkeypatch.setenv("NETRC", str(netrc)) - monkeypatch.delenv("http_proxy", raising=False) - monkeypatch.delenv("no_proxy", raising=False) - monkeypatch.setenv("NO_PROXY", "") - async def scenario(): - async with wire_client("async") as (client, server): - monkeypatch.setenv("HTTP_PROXY", server.url) - client.service = "http://127.0.0.2:1" - await client.get_assembly(assembly_id=ASSEMBLY_ID) - client.bearer_token = "selected-token" - await client.list_templates() - for request in server.requests: - assert request["headers"]["Proxy-Authorization"] == aiohttp.BasicAuth("proxy-user", "proxy-password").encode() - assert "Authorization" not in server.requests[0]["headers"] - assert server.requests[1]["headers"]["Authorization"] == "Bearer selected-token" - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("filename", ["my photo.jpg", "caf\u00e9.jpg", "quote\"name.txt", "newline\r\nname.txt"]) -def test_multipart_preserves_original_filename(mode, filename): - async def scenario(): - async with wire_client(mode) as (client, server): - upload = io.BytesIO(b"data") - upload.name = filename - await call(client, "create_assembly", files={"file": upload}) - # Quoting must prevent header injection while preserving spaces/UTF-8. - expected = filename.replace("\r", "%0D").replace("\n", "%0A").replace('"', '%22') - assert server.requests[-1]["filenames"]["file"] == expected - assert not upload.closed - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_multipart_field_names_cannot_inject_headers(mode): - async def scenario(): - async with wire_client(mode) as (client, server): - await call(client, "create_assembly", files={"file\r\nname": io.BytesIO(b"data")}, - extra_data={"quoted\"field": "value"}) - assert server.requests[-1]["fields"]["file%0D%0Aname"] == b"data" - assert server.requests[-1]["fields"]["quoted%22field"] == "value" - asyncio.run(scenario()) - - -ASSEMBLY_ID = "a" * 32 - - -class WireServer: - def __init__(self): - self.requests = [] - self.upload = b"" - self.disconnected = asyncio.Event() - self.started = asyncio.Event() - self.stream_mode = "normal" - - async def handle(self, request): - data = b"" - fields = {} - filenames = {} - if request.content_type == "multipart/form-data": - for key, value in (await request.post()).items(): - fields[key] = value.file.read() if isinstance(value, web.FileField) else value - if isinstance(value, web.FileField): - filenames[key] = value.filename - else: - data = await request.read() - if request.content_type == "application/x-www-form-urlencoded": - fields = {key: values[0] for key, values in parse_qs(data.decode()).items()} - record = {"method": request.method, "path": request.path, "body": data, "filenames": filenames, - "fields": fields, "query": dict(request.query), "headers": CaseInsensitiveDict(request.headers)} - self.requests.append(record) - if request.method == "GET" and request.path == "/assemblies/" + ASSEMBLY_ID: - return web.json_response({"ok": "ASSEMBLY_COMPLETED", "assembly_id": ASSEMBLY_ID}) - if request.method == "POST" and request.path == "/assemblies" and hasattr(self, "assembly_response"): - return web.json_response(self.assembly_response) - if request.path == "/ws1": - if self.stream_mode == "redirect": - return web.Response(status=302, headers={"Location": self.url + "/redirect-target"}) - if self.stream_mode == "unavailable": - return web.Response(status=503) - response = web.StreamResponse(headers={"Content-Type": "text/event-stream"}) - await response.prepare(request) - try: - if self.stream_mode == "normal": - payload = ('\ufeff: heartbeat\r\nevent: assembly_execution_progress\r\n' - 'data: {"progress_combined": 50,\r\ndata: "label": "café"}\r\n\r\n' - 'event: future_event\ndata: {"value": true}\n\n' - 'data: assembly_finished\n\n' - 'data: must_not_be_delivered\n\n').encode() - for byte in payload: - await response.write(bytes([byte])) - else: - await response.write(b"data: ping\n\n") - self.started.set() - while request.transport is not None and not request.transport.is_closing(): - await asyncio.sleep(.01) - await response.write(b": heartbeat\n\n") - self.disconnected.set() - except (ConnectionResetError, asyncio.CancelledError): - self.disconnected.set() - return response - if request.path == "/resumable/files": - if request.method == "OPTIONS": - return web.Response(status=204, headers={"Tus-Version": "1.0.0", "Tus-Extension": "creation,termination"}) - self.upload = data - return web.Response(status=201, headers={"Location": "/resumable/files/upload-1", "Upload-Offset": str(len(data))}) - if request.path == "/resumable/files/upload-1": - if request.method == "HEAD": - return web.Response(headers={"Upload-Offset": str(len(self.upload)), "Upload-Length": "6"}) - if request.method == "PATCH": - assert int(request.headers["Upload-Offset"]) == len(self.upload) - self.upload += data - return web.Response(status=204, headers={"Upload-Offset": str(len(self.upload))}) - if request.method == "DELETE": - self.upload = b"" - return web.Response(status=204) - if request.headers.get("Range") == "bytes=1-2": - return web.Response(status=206, body=self.upload[1:3], headers={"Content-Range": "bytes 1-2/6"}) - return web.Response(body=self.upload, content_type="application/octet-stream") - return web.json_response({"ok": "OK", "access_token": "token-value"}) - - -@asynccontextmanager -async def wire_client(mode, *, bearer_token=None): - server = WireServer() - app = web.Application() - app.router.add_route("*", "/{path:.*}", server.handle) - runner = web.AppRunner(app, shutdown_timeout=.1) - await runner.setup() - site = web.TCPSite(runner, "127.0.0.1", 0) - await site.start() - server.url = "http://127.0.0.1:" + str(site._server.sockets[0].getsockname()[1]) - cls = Transloadit if mode == "sync" else AsyncTransloadit - client = cls("key", "secret", service=server.url, bearer_token=bearer_token) - try: - yield client, server - finally: - if mode == "async": - await client.aclose() - await runner.cleanup() - - -async def call(client, method, *args, **kwargs): - operation = getattr(client, method) - if isinstance(client, AsyncTransloadit): - return await operation(*args, **kwargs) - return await asyncio.to_thread(operation, *args, **kwargs) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("name,verb,path,args", [ - ("create_auth_key", "POST", "/auth_keys", ()), - ("delete_auth_key", "DELETE", "/auth_keys/key-id", ("key-id",)), - ("update_auth_key", "PUT", "/auth_keys/key-id", ("key-id",)), - ("list_auth_keys", "GET", "/auth_keys", ()), - ("list_auth_key_scopes", "GET", "/auth_keys/scopes", ()), - ("show_auth_key_secret", "POST", "/auth_keys/show_secret/key-id", ("key-id",)), - ("get_dam_asset", "GET", "/dam/assets/asset-id", ("asset-id",)), - ("list_dam_assets", "GET", "/dam/assets", ()), - ("move_dam_asset", "PATCH", "/dam/assets/asset-id", ("asset-id",)), - ("move_dam_entry", "POST", "/dam/entries/move", ()), - ("delete_dam_asset", "DELETE", "/dam/assets/asset-id", ("asset-id",)), - ("bulk_move_dam_assets", "POST", "/dam/assets/bulk/move", ()), - ("bulk_delete_dam_assets", "POST", "/dam/assets/bulk/delete", ()), - ("assembly_stats", "GET", "/assembly_stats", ()), - ("priority_job_slot_stats", "GET", "/priority_job_slot_stats", ()), -]) -def test_new_endpoints_preserve_signed_wire_payload(mode, name, verb, path, args): - async def scenario(): - async with wire_client(mode) as (client, server): - payload = {"custom": {"nested": [False, 3]}, "auth": {"max_size": 1024}} - original = json.loads(json.dumps(payload)) - response = await call(client, name, *args, **{"params" if verb == "GET" else "data": payload}) - request = server.requests[-1] - assert (request["method"], request["path"]) == (verb, path) - fields = request["query"] if verb == "GET" else request["fields"] - params = json.loads(fields["params"]) - assert params["custom"] == payload["custom"] - assert params["auth"]["max_size"] == 1024 - assert params["auth"]["key"] == "key" - expected = hmac.new(b"secret", fields["params"].encode(), hashlib.sha384).hexdigest() - assert fields["signature"] == "sha384:" + expected - assert payload == original - assert response.data["ok"] == "OK" - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_replacement_sends_multipart_and_keeps_file_open(mode): - async def scenario(): - async with wire_client(mode) as (client, server): - stream = io.BytesIO(b"file bytes") - await call(client, "replace_assembly", ASSEMBLY_ID, {"steps": {}}, {"field": True}, {"file": stream}) - request = server.requests[-1] - assert request["method"] == "PUT" - assert request["path"] == "/assemblies/" + ASSEMBLY_ID - assert request["fields"]["file"] == b"file bytes" - assert request["fields"]["field"] == "True" - assert json.loads(request["fields"]["params"])["steps"] == {} - assert not stream.closed - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_bearer_requests_and_public_notifications_have_distinct_auth(mode): - async def scenario(): - async with wire_client(mode, bearer_token="bearer-value") as (client, server): - await call(client, "list_auth_keys", {"fields": ["name"]}) - request = server.requests[-1] - assert request["headers"]["Authorization"] == "Bearer bearer-value" - assert json.loads(request["query"]["params"]) == {"fields": ["name"]} - assert "signature" not in request["query"] - await call(client, "list_assembly_notifications", ASSEMBLY_ID, {"page": 2}) - request = server.requests[-1] - assert "Authorization" not in request["headers"] - assert request["query"] == {"page": "2"} - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("data,authorization", [ - ({"scope": "assemblies:read"}, "Basic a2V5OnNlY3JldA=="), - ({"grant_type": "authorization_code", "code": "code", "code_verifier": "proof", "client_id": "id", "redirect_uri": "https://example.test/callback"}, None), - ({"grant_type": "refresh_token", "refresh_token": "refresh", "client_id": "id", "resource": "https://api2.transloadit.com"}, None), -]) -def test_token_grants_forward_fields_with_contract_auth(mode, data, authorization): - async def scenario(): - async with wire_client(mode) as (client, server): - if authorization is None: - client.auth_secret = None - response = await call(client, "issue_bearer_token", data) - request = server.requests[-1] - assert (request["method"], request["path"]) == ("POST", "/token") - assert request["headers"].get("Authorization") == authorization - assert request["fields"] == {"grant_type": "client_credentials", **data} - assert "signature" not in request["fields"] - assert response.data["access_token"] == "token-value" - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_all_six_raw_tus_operations(mode): - async def scenario(): - async with wire_client(mode, bearer_token="must-not-leak") as (client, server): - assembly = {"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": server.url + "/assemblies/" + ASSEMBLY_ID, - "tus_url": server.url + "/resumable/files"} - response = await call(client, "tus_options", assembly) - assert response.headers["tus-version"] == "1.0.0" - response = await call(client, "create_upload", assembly, headers={"Upload-Length": "6"}, body=b"{a") - assert response.status_code == 201 - assert response.headers["Location"] == "/resumable/files/upload-1" - upload_url = response.upload_url - request = server.requests[-1] - metadata = request["headers"]["Upload-Metadata"].split(" ", 1)[1] - assert base64.b64decode(metadata).decode() == assembly["assembly_ssl_url"] - response = await call(client, "get_upload_offset", upload_url) - assert response.headers["upload-offset"] == "2" - response = await call(client, "patch_upload", upload_url, headers={"Upload-Offset": "2"}, body=b"bc}\xff") - assert response.headers["Upload-Offset"] == "6" - response = await call(client, "download_upload", upload_url) - assert response.data == b"{abc}\xff" - response = await call(client, "download_upload", upload_url, headers={"Range": "bytes=1-2"}) - assert response.status_code == 206 and response.data == b"ab" - response = await call(client, "delete_upload", upload_url) - assert response.status_code == 204 and server.upload == b"" - for request in server.requests: - assert "Authorization" not in request["headers"] - assert "params" not in request["query"] - assert "signature" not in request["query"] - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_stream_decodes_split_unicode_multiline_and_terminal_events(mode): - async def scenario(): - async with wire_client(mode, bearer_token="must-not-leak") as (client, server): - url = server.url + "/ws1?assembly=" + ASSEMBLY_ID - if mode == "sync": - def consume(): - with client.stream_assembly_status(url) as events: - return list(events) - events = await asyncio.to_thread(consume) - else: - async with client.stream_assembly_status(url) as stream: - events = [event async for event in stream] - assert [e.event for e in events] == ["assembly_execution_progress", "future_event", "assembly_finished"] - assert events[0].data == {"progress_combined": 50, "label": "café"} - assert events[-1].terminal - assert server.requests[-1]["headers"]["Accept"] == "text/event-stream" - assert "Authorization" not in server.requests[-1]["headers"] - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("behavior,status", [("redirect", 302), ("unavailable", 503)]) -def test_stream_errors_do_not_follow_redirects(mode, behavior, status): - async def scenario(): - async with wire_client(mode) as (client, server): - server.stream_mode = behavior - url = server.url + "/ws1?assembly=" + ASSEMBLY_ID - with pytest.raises(StreamError) as caught: - if mode == "sync": - def consume(): - with client.stream_assembly_status(url) as events: - list(events) - await asyncio.to_thread(consume) - else: - async with client.stream_assembly_status(url): - pass - assert caught.value.status_code == status - assert len(server.requests) == 1 - asyncio.run(scenario()) - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_stream_early_exit_closes_connection(mode): - async def scenario(): - async with wire_client(mode) as (client, server): - server.stream_mode = "held" - url = server.url + "/ws1?assembly=" + ASSEMBLY_ID - if mode == "sync": - def consume(): - with client.stream_assembly_status(url) as events: - assert next(events).event == "ping" - await asyncio.to_thread(consume) - else: - consumed = asyncio.Event() - async def consume(): - async with client.stream_assembly_status(url) as events: - assert (await anext(events)).event == "ping" - consumed.set() - await asyncio.sleep(100) - task = asyncio.create_task(consume()) - await asyncio.wait_for(consumed.wait(), 10) - task.cancel() - with pytest.raises(asyncio.CancelledError): - await task - await asyncio.wait_for(server.disconnected.wait(), 10) - asyncio.run(scenario()) - - -def test_event_parser_bounds_and_eof_behavior(): - parser = EventParser(max_event_size=30) - with pytest.raises(ValueError, match="max_event_size"): - list(parser.feed(b"data: " + b"a" * 31)) - parser = EventParser() - assert list(parser.feed(b"data: incomplete")) == [] - parser = EventParser() - events = list(parser.feed(b"id: 2\nretry: 123\nevent: assembly_error\ndata: {\"error\":\"failed\"}\n\n")) - assert events[0].id == "2" and events[0].retry == 123 - assert events[0].terminal and events[0].data["error"] == "failed" - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -@pytest.mark.parametrize("url", [ - "https://evil.test/resumable/files/x", "https://api2.transloadit.com.evil.test/resumable/files/x", - "https://user:password@api2.transloadit.com/resumable/files/x", "http://api2.transloadit.com/resumable/files/x", - "https://api2.transloadit.com/resumable/files/../admin", "https://api2.transloadit.com/resumable/files/%2e%2e/admin", - "https://api2.transloadit.com/templates/x", "https://api2.transloadit.com/resumable/files/x#fragment", - "https://api2.transloadit.com/resumable/files/%252e%252e", - "https://api2.transloadit.com/resumable/files/a%2Fb", - "https://api2.transloadit.com/resumable/files/%ff", - "https://api2.transloadit.com/resumable/files/x?", -]) -def test_raw_upload_rejects_untrusted_capabilities(mode, url): - async def scenario(): - cls = Transloadit if mode == "sync" else AsyncTransloadit - client = cls("key", "secret") - try: - with pytest.raises(ValueError): - await call(client, "get_upload_offset", url) - finally: - if mode == "async": - await client.aclose() - asyncio.run(scenario()) - - -def test_generation_check(): - root = Path(__file__).resolve().parents[1] - subprocess.run([sys.executable, "scripts/generate_endpoints.py", "--check"], cwd=root, check=True) - - -def test_assembly_and_tus_can_use_distinct_trusted_regional_hosts(): - assembly = { - "assembly_id": ASSEMBLY_ID, - "assembly_ssl_url": "https://api2-cell.transloadit.com/assemblies/" + ASSEMBLY_ID, - "tus_url": "https://api2-region.transloadit.com/resumable/files/", - } - _, url, headers, _ = tus_request(Transloadit("key", "secret"), "tusd.create-upload", assembly, {"Upload-Length": "1"}, None) - assert url == assembly["tus_url"] - assert base64.b64decode(headers["upload-metadata"].split(" ", 1)[1]).decode() == assembly["assembly_ssl_url"] - - -@pytest.mark.parametrize("location", [ - "https://evil.test/resumable/files/id", "/resumable/files/../files/id", "/resumable/files/%2e%2e/id", "", -]) -def test_creation_rejects_untrusted_or_normalized_locations(location): - client = Transloadit("key", "secret") - response = Response(data="", status_code=201, headers=CaseInsensitiveDict({"Location": location})) - with pytest.raises(ValueError): - validate_upload_location(client, "https://api2-region.transloadit.com/resumable/files/", response) - - -def test_creation_accepts_location_from_another_trusted_uploader(): - client = Transloadit("key", "secret") - location = "https://api2-cell.transloadit.com/resumable/files/id" - response = Response(data="", status_code=201, headers=CaseInsensitiveDict({"Location": location})) - validate_upload_location(client, "https://api2-region.transloadit.com/resumable/files/", response) - assert response.upload_url == location - - -@pytest.mark.parametrize("field,value", [("Authorization", "Bearer secret"), ("Cookie", "session=secret"), ("Host", "evil.test")]) -def test_tus_rejects_ambient_credentials(field, value): - with pytest.raises(ValueError): - tus_request(Transloadit("key", "secret"), "tusd.get-upload-offset", - "https://api2-region.transloadit.com/resumable/files/id", {field: value}, None) - - -def test_tus_metadata_cannot_change_assembly_identity(): - assembly = {"assembly_id": ASSEMBLY_ID, - "assembly_ssl_url": "https://api2-cell.transloadit.com/assemblies/" + ASSEMBLY_ID, - "tus_url": "https://api2-region.transloadit.com/resumable/files/"} - client = Transloadit("key", "secret") - with pytest.raises(ValueError, match="override"): - tus_request(client, "tusd.create-upload", assembly, {"Upload-Metadata": "assembly_url YXR0YWNr"}, None) - assembly["assembly_id"] = "b" * 32 - with pytest.raises(ValueError, match="identity"): - tus_request(client, "tusd.create-upload", assembly, {}, None) diff --git a/tests/test_e2e_endpoints.py b/tests/test_e2e_endpoints.py deleted file mode 100644 index 1d27284..0000000 --- a/tests/test_e2e_endpoints.py +++ /dev/null @@ -1,85 +0,0 @@ -"""Opt-in test-account validation using the repository's existing E2E credentials.""" -import asyncio -import base64 -import os - -import pytest - -from transloadit.async_client import AsyncTransloadit -from transloadit.client import Transloadit -from .test_e2e_upload import _get_e2e_credentials, _is_enabled - - -pytestmark = [pytest.mark.e2e, pytest.mark.skipif(not _is_enabled(), reason="Set PYTHON_SDK_E2E=1")] - - -@pytest.mark.parametrize("mode", ["sync", "async"]) -def test_raw_tus_and_status_stream_lifecycle(mode): - async def scenario(): - key, secret = _get_e2e_credentials() - cls = Transloadit if mode == "sync" else AsyncTransloadit - client = cls(key, secret, service=os.getenv("TRANSLOADIT_SERVICE", "https://api2.transloadit.com")) - - async def call(name, *args, **kwargs): - if mode == "async": - return await getattr(client, name)(*args, **kwargs) - return await asyncio.to_thread(getattr(client, name), *args, **kwargs) - - assembly_url = None - stream_task = None - try: - scopes = await call("list_auth_key_scopes") - assert scopes.status_code == 200 - # Keep the Assembly waiting while its incomplete upload is tested/deleted. - assembly = await call("create_tus_assembly", 2) - assert assembly.status_code == 200 - assembly_url = assembly.data["assembly_ssl_url"] - options = await call("tus_options", assembly) - assert options.status_code in {200, 204} - assert "1.0.0" in options.headers["Tus-Version"] - metadata = "filename " + base64.b64encode(b"sdk-test.bin").decode() + ",fieldname " + base64.b64encode(b"file").decode() - created = await call("create_upload", assembly, headers={"Upload-Length": "16", "Upload-Metadata": metadata}) - assert created.status_code == 201, created.data - upload_url = created.upload_url - offset = await call("get_upload_offset", upload_url) - assert offset.status_code == 200 and offset.headers["Upload-Offset"] == "0" - appended = await call("patch_upload", upload_url, headers={"Upload-Offset": "0"}, body=b"sdk-test") - assert appended.status_code == 204 and appended.headers["Upload-Offset"] == "8" - downloaded = await call("download_upload", upload_url, headers={"Range": "bytes=1-3"}) - assert downloaded.status_code == 206 and downloaded.data == b"dk-" - deleted = await call("delete_upload", upload_url) - assert deleted.status_code == 204 - - opened = asyncio.Event() - loop = asyncio.get_running_loop() - stream_url = assembly.data["update_stream_url"] - - def consume_sync(): - with client.stream_assembly_status(stream_url, read_timeout=15) as events: - loop.call_soon_threadsafe(opened.set) - return list(events) - - async def consume_async(): - async with client.stream_assembly_status(stream_url, read_timeout=15) as events: - opened.set() - return [event async for event in events] - - stream_task = asyncio.create_task(consume_async() if mode == "async" else asyncio.to_thread(consume_sync)) - await asyncio.wait_for(opened.wait(), 20) - canceled = await call("cancel_assembly", assembly_url=assembly_url) - assert canceled.status_code == 200 - events = await asyncio.wait_for(asyncio.shield(stream_task), 20) - assert any(event.terminal for event in events) - status = await call("get_assembly", assembly_url=assembly_url) - assert status.data["ok"] == "ASSEMBLY_CANCELED" - finally: - try: - if assembly_url: - await call("cancel_assembly", assembly_url=assembly_url) - finally: - if stream_task: - # Sync stream reads have a finite timeout; await the owned worker. - await asyncio.gather(stream_task, return_exceptions=True) - if mode == "async": - await client.aclose() - asyncio.run(scenario()) diff --git a/tests/test_e2e_upload.py b/tests/test_e2e_upload.py index f3c6ec7..a7bf678 100644 --- a/tests/test_e2e_upload.py +++ b/tests/test_e2e_upload.py @@ -53,8 +53,11 @@ def _add_resize_step(assembly, width=128, height=128): def _assert_e2e_image_resize(data, fixture_path, expected_field=None, expected_fields=None): - assembly_ssl_url = data.get("assembly_ssl_url") or data.get("assembly_url") - assembly_id = data.get("assembly_id") + assembly_ssl_url = data["assembly_ssl_url"] + assembly_id = data["assembly_id"] + assert assembly_id, data + assert assembly_ssl_url.startswith("https://"), data + assert data["assembly_url"], data print(f"[python-sdk][e2e] Assembly URL: {assembly_ssl_url} (id={assembly_id})") assert data.get("ok") == "ASSEMBLY_COMPLETED", data @@ -98,22 +101,14 @@ def _assert_e2e_image_resize(data, fixture_path, expected_field=None, expected_f def _extract_template_id(data): - template_id = data.get("id") or data.get("template_id") + template_id = data.get("id") assert template_id, f"Template response did not contain an id: {data}" return template_id -def _extract_template_name(data): - return data.get("name") or data.get("template_name") - - -def _extract_template_content(data): - return data.get("content") or data.get("template_content") or data.get("template") - - def _assert_template(data, expected_name, expected_width): - assert _extract_template_name(data) == expected_name, data - content = _extract_template_content(data) + assert data["name"] == expected_name, data + content = data["content"] assert isinstance(content, dict), data steps = content.get("steps") or {} resize = steps.get("resize") or {} diff --git a/tests/test_examples.py b/tests/test_examples.py index 14d4f07..0ef664a 100644 --- a/tests/test_examples.py +++ b/tests/test_examples.py @@ -36,9 +36,66 @@ def test_examples_import_without_side_effects(): runpy.run_path(str(example_path), run_name="__example_import__") -def test_devdock_examples_import_without_side_effects(): - for example_path in sorted(EXAMPLES_ROOT.glob("api2-devdock-*/main.py")): - runpy.run_path(str(example_path), run_name="__example_import__") +@pytest.mark.parametrize( + "example_name", + ["assembly_with_template.py", "template_lifecycle.py", "async_template_lifecycle.py"], +) +def test_template_examples_require_documented_id(example_name): + namespace = runpy.run_path(str(EXAMPLES_ROOT / example_name), run_name="__example_import__") + extract_id = namespace["extract_template_id"] + + assert extract_id({"id": "documented-id", "template_id": "alias-id"}) == "documented-id" + with pytest.raises(RuntimeError, match="did not contain an id"): + extract_id({"template_id": "alias-id"}) + + +@pytest.mark.parametrize( + "field, alias", + [ + ("name", "template_name"), + ("content", "template_content"), + ("content", "template"), + ], +) +def test_template_e2e_assertion_rejects_response_aliases(field, alias): + namespace = runpy.run_path(str(REPO_ROOT / "tests" / "test_e2e_upload.py")) + data = { + "name": "resize", + "content": {"steps": {"resize": {"robot": "/image/resize", "width": 64}}}, + } + namespace["_assert_template"](data, "resize", 64) + data[alias] = data.pop(field) + + with pytest.raises(KeyError): + namespace["_assert_template"](data, "resize", 64) + + +@pytest.mark.parametrize("missing_field", ["assembly_id", "assembly_ssl_url", "assembly_url"]) +def test_assembly_e2e_assertion_requires_documented_fields(missing_field): + namespace = runpy.run_path(str(REPO_ROOT / "tests" / "test_e2e_upload.py")) + data = { + "assembly_id": "assembly-id", + "assembly_ssl_url": "https://api2.transloadit.com/assemblies/assembly-id", + "assembly_url": "http://api2.transloadit.com/assemblies/assembly-id", + "ok": "ASSEMBLY_COMPLETED", + "uploads": [{"name": "fixture.jpg", "basename": "fixture"}], + "results": { + "resize": [ + {"ssl_url": "https://example.com/image.png", "meta": {"width": 64, "height": 64}}, + ], + }, + } + namespace["_assert_e2e_image_resize"](data, Path("fixture.jpg")) + aliases = { + "assembly_id": "assemblyId", + "assembly_ssl_url": "assemblySslUrl", + "assembly_url": "assemblyUrl", + } + data[aliases[missing_field]] = data[missing_field] + del data[missing_field] + + with pytest.raises(KeyError, match=missing_field): + namespace["_assert_e2e_image_resize"](data, Path("fixture.jpg")) def test_smart_cdn_example_runs_without_network(): diff --git a/tests/test_template.py b/tests/test_template.py index 415ba11..c01d44a 100644 --- a/tests/test_template.py +++ b/tests/test_template.py @@ -22,14 +22,14 @@ def test_save(self, mock): ) mock.post( url, - text='{"ok":"TEMPLATE_CREATED","template_name":"foo"}', + text='{"ok":"TEMPLATE_CREATED","id":"template-1","name":"foo","content":{"steps":{}}}', additional_matcher=request_body_matcher(urllib.parse.quote_plus(sub_body)), ) self.template.add_step("resize", "/image/resize", {"width": 70, "height": 70}) template = self.template.create() self.assertEqual(template.data["ok"], "TEMPLATE_CREATED") - self.assertEqual(template.data["template_name"], "foo") + self.assertEqual(template.data["name"], "foo") def test_create_preserves_string_template_payload(self): template = self.transloadit.new_template( diff --git a/tests/test_transport.py b/tests/test_transport.py new file mode 100644 index 0000000..cc047c8 --- /dev/null +++ b/tests/test_transport.py @@ -0,0 +1,304 @@ +"""Behavioral coverage for handwritten Assembly requests and multipart uploads.""" +import asyncio +import io +from contextlib import asynccontextmanager +from urllib.parse import parse_qs +from unittest import mock + +import aiohttp +from aiohttp import web +import pytest +from requests.structures import CaseInsensitiveDict + +from transloadit.client import Transloadit +from transloadit.async_client import AsyncTransloadit + +ASSEMBLY_ID = "a" * 32 + + +class WireServer: + def __init__(self): + self.requests = [] + + async def handle(self, request): + data = b"" + fields = {} + filenames = {} + if request.content_type == "multipart/form-data": + for key, value in (await request.post()).items(): + fields[key] = value.file.read() if isinstance(value, web.FileField) else value + if isinstance(value, web.FileField): + filenames[key] = value.filename + else: + data = await request.read() + if request.content_type == "application/x-www-form-urlencoded": + fields = {key: values[0] for key, values in parse_qs(data.decode()).items()} + self.requests.append({"method": request.method, "path": request.path, "body": data, + "filenames": filenames, "fields": fields, "query": dict(request.query), + "headers": CaseInsensitiveDict(request.headers)}) + if request.method == "GET" and request.path == "/assemblies/" + ASSEMBLY_ID: + return web.json_response({"ok": "ASSEMBLY_COMPLETED", "assembly_id": ASSEMBLY_ID}) + if request.method == "POST" and request.path == "/assemblies" and hasattr(self, "assembly_response"): + return web.json_response(self.assembly_response) + return web.json_response({"ok": "OK"}) + + +def test_sync_isolated_transport_preserves_proxy_and_ca_settings(requests_mock, monkeypatch, tmp_path): + url = "https://api2.transloadit.com/assemblies/" + ASSEMBLY_ID + endpoint = requests_mock.get(url, json={"ok": "OK"}) + monkeypatch.delenv("https_proxy", raising=False) + monkeypatch.setenv("HTTPS_PROXY", "http://proxy.invalid:3128") + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + monkeypatch.setenv("REQUESTS_CA_BUNDLE", "/custom/company-ca.pem") + netrc = tmp_path / "netrc" + netrc.write_text("machine api2.transloadit.com login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + Transloadit("key", "secret").get_assembly(assembly_id=ASSEMBLY_ID) + assert endpoint.last_request.proxies["https"] == "http://proxy.invalid:3128" + assert endpoint.last_request.verify == "/custom/company-ca.pem" + assert "Authorization" not in endpoint.last_request.headers + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_isolated_transports_use_environment_proxy_without_netrc(mode, monkeypatch, tmp_path): + async def scenario(): + async with wire_client(mode) as (client, server): + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.setenv("HTTP_PROXY", server.url) + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.2 login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + # No server listens here: every request must traverse the proxy. + client.service = "http://127.0.0.2:1" + await call(client, "get_assembly", assembly_id=ASSEMBLY_ID) + await call(client, "cancel_assembly", assembly_id=ASSEMBLY_ID) + assert len(server.requests) == 2 + assert all("Authorization" not in request["headers"] for request in server.requests) + asyncio.run(scenario()) + + +def test_async_isolated_transport_reuses_injected_connector_without_credentials(monkeypatch): + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "sdk.invalid") + async def scenario(): + async with wire_client("async") as (_, server): + class Resolver(aiohttp.abc.AbstractResolver): + async def resolve(self, host, port=0, family=0): + return [{"hostname": host, "host": "127.0.0.1", "port": port, "family": 2, "proto": 0, "flags": 0}] + async def close(self): + pass + connector = aiohttp.TCPConnector(resolver=Resolver()) + async with aiohttp.ClientSession(connector=connector, auth=aiohttp.BasicAuth("ambient", "secret"), + headers={"Cookie": "session=must-not-leak"}) as session: + service = server.url.replace("127.0.0.1", "sdk.invalid") + async with AsyncTransloadit("key", "secret", service=service, session=session) as client: + await client.get_assembly(assembly_id=ASSEMBLY_ID) + assert not connector.closed and not session.closed + assert "Authorization" not in server.requests[-1]["headers"] + assert "Cookie" not in server.requests[-1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_assembly_capabilities_do_not_borrow_account_credentials(mode, monkeypatch, tmp_path): + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.1 login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + async def scenario(): + async with wire_client(mode) as (client, server): + async with aiohttp.ClientSession(auth=aiohttp.BasicAuth("ambient", "secret"), + headers={"Cookie": "ambient-cookie"}) as session: + if mode == "async": + client = AsyncTransloadit("key", "secret", service=server.url, session=session) + await call(client, "get_assembly", assembly_id=ASSEMBLY_ID) + await call(client, "cancel_assembly", assembly_url=server.url + "/assemblies/" + ASSEMBLY_ID) + assert len(server.requests) == 2 + for request in server.requests: + assert "Authorization" not in request["headers"] + assert "Cookie" not in request["headers"] + assert request["query"] == {} + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("encoding,line_ending", [("utf-8", "\n"), ("utf-8", "\r\n"), ("utf-16", "\n")]) +def test_text_mode_multipart_preserves_content_and_file_ownership(mode, tmp_path, encoding, line_ending): + path = tmp_path / "text.txt" + path.write_bytes(("caf\u00e9" + line_ending).encode(encoding)) + async def scenario(): + async with wire_client(mode) as (client, server): + if mode == "async": + client.request._timeout = lambda: aiohttp.ClientTimeout(total=5) + assembly = client.new_assembly() + with path.open(encoding=encoding) as upload: + assembly.add_file(upload, "text") + if mode == "sync": + await asyncio.to_thread(assembly.create, resumable=False) + else: + await assembly.create(resumable=False) + assert not upload.closed + assert server.requests[-1]["fields"]["text"] == "caf\u00e9\n".encode() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_custom_service_can_poll_returned_worker_origin(mode): + async def scenario(): + async with wire_client(mode) as (client, server), wire_client(mode) as (_, worker): + server.assembly_response = {"ok": "ASSEMBLY_UPLOADING", "assembly_id": ASSEMBLY_ID, + "assembly_ssl_url": worker.url + "/assemblies/" + ASSEMBLY_ID} + assembly = client.new_assembly() + sleep_path = "transloadit.assembly.sleep" if mode == "sync" else "transloadit.async_assembly.asyncio.sleep" + with mock.patch(sleep_path, new_callable=mock.Mock if mode == "sync" else mock.AsyncMock): + if mode == "sync": + result = await asyncio.to_thread(assembly.create, wait=True) + else: + result = await assembly.create(wait=True) + assert result.data["ok"] == "ASSEMBLY_COMPLETED" + assert "Authorization" not in worker.requests[-1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("host", ["api2.transloadit.com", "api2-morven.transloadit.com"]) +def test_legacy_http_assembly_urls_use_https(mode, host): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() + for method, verb in [("get_assembly", "GET"), ("cancel_assembly", "DELETE")]: + await call(client, method, assembly_url=f"http://{host}/assemblies/{ASSEMBLY_ID}") + client.request.public.assert_called_with(verb, f"https://{host}/assemblies/{ASSEMBLY_ID}", params=None) + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("host", ["api2-x.other.transloadit.com", "api2-xn--example.transloadit.com"]) +def test_assembly_urls_reject_non_api_hosts(mode, host): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() + with pytest.raises(ValueError, match="untrusted Assembly URL"): + await call(client, "get_assembly", assembly_url=f"https://{host}/assemblies/{ASSEMBLY_ID}") + client.request.public.assert_not_called() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("trust_env", [False, True]) +def test_isolated_async_calls_preserve_explicit_proxy_configuration(monkeypatch, trust_env): + # The injected proxy takes precedence over an unusable environment proxy. + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.3:1") + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (_, server): + proxy_auth = aiohttp.BasicAuth("proxy-user", "proxy-password") + async with aiohttp.ClientSession(proxy=server.url, proxy_auth=proxy_auth, trust_env=trust_env) as session: + service = "http://127.0.0.2:1" + client = AsyncTransloadit("key", "secret", service=service, session=session) + await client.list_templates() + await client.get_assembly(assembly_id=ASSEMBLY_ID) + await client.cancel_assembly(assembly_id=ASSEMBLY_ID) + assert not session.closed + assert len(server.requests) == 3 + assert all(request["headers"]["Proxy-Authorization"] == proxy_auth.encode() for request in server.requests) + assert all("Authorization" not in request["headers"] for request in server.requests) + asyncio.run(scenario()) + + +def test_async_proxy_selection_matches_signed_calls_with_all_proxy(monkeypatch): + for name in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "no_proxy"): + monkeypatch.delenv(name, raising=False) + monkeypatch.setenv("ALL_PROXY", "socks5://127.0.0.2:1") + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (client, server): + await client.list_templates() + await client.get_assembly(assembly_id=ASSEMBLY_ID) + assert len(server.requests) == 2 + asyncio.run(scenario()) + + +def test_async_environment_proxy_preserves_proxy_netrc_only(monkeypatch, tmp_path): + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.1 login proxy-user password proxy-password\nmachine 127.0.0.2 login origin-user password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (client, server): + monkeypatch.setenv("HTTP_PROXY", server.url) + client.service = "http://127.0.0.2:1" + await client.get_assembly(assembly_id=ASSEMBLY_ID) + await client.cancel_assembly(assembly_id=ASSEMBLY_ID) + for request in server.requests: + assert request["headers"]["Proxy-Authorization"] == aiohttp.BasicAuth("proxy-user", "proxy-password").encode() + assert "Authorization" not in server.requests[0]["headers"] + assert "Authorization" not in server.requests[1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("filename", ["my photo.jpg", "caf\u00e9.jpg", "quote\"name.txt", "newline\r\nname.txt"]) +def test_multipart_preserves_original_filename(mode, filename): + async def scenario(): + async with wire_client(mode) as (client, server): + upload = io.BytesIO(b"data") + upload.name = filename + assembly = client.new_assembly() + assembly.add_file(upload) + if mode == "async": + await assembly.create(resumable=False) + else: + await asyncio.to_thread(assembly.create, resumable=False) + # Quoting must prevent header injection while preserving spaces/UTF-8. + expected = filename.replace("\r", "%0D").replace("\n", "%0A").replace('"', '%22') + assert server.requests[-1]["filenames"]["file"] == expected + assert not upload.closed + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_multipart_field_names_cannot_inject_headers(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + options = {"files": {"file\r\nname": io.BytesIO(b"data")}, + "extra_data": {"quoted\"field": "value"}} + if mode == "async": + await client.request.post("/assemblies", **options) + else: + await asyncio.to_thread(client.request.post, "/assemblies", **options) + assert server.requests[-1]["fields"]["file%0D%0Aname"] == b"data" + assert server.requests[-1]["fields"]["quoted%22field"] == "value" + asyncio.run(scenario()) + + +@asynccontextmanager +async def wire_client(mode): + server = WireServer() + app = web.Application() + app.router.add_route("*", "/{path:.*}", server.handle) + runner = web.AppRunner(app, shutdown_timeout=.1) + await runner.setup() + site = web.TCPSite(runner, "127.0.0.1", 0) + await site.start() + server.url = "http://127.0.0.1:" + str(site._server.sockets[0].getsockname()[1]) + cls = Transloadit if mode == "sync" else AsyncTransloadit + client = cls("key", "secret", service=server.url) + try: + yield client, server + finally: + if mode == "async": + await client.aclose() + await runner.cleanup() + + +async def call(client, method, *args, **kwargs): + operation = getattr(client, method) + if isinstance(client, AsyncTransloadit): + return await operation(*args, **kwargs) + return await asyncio.to_thread(operation, *args, **kwargs) diff --git a/tests/test_upload_cleanup.py b/tests/test_upload_cleanup.py index 8ebf2ae..9944022 100644 --- a/tests/test_upload_cleanup.py +++ b/tests/test_upload_cleanup.py @@ -35,7 +35,9 @@ def post(self, url, **kwargs): return Context(kwargs["data"]) upload = SlowStream(b"payload") client = AsyncTransloadit("key", "secret", session=Session()) - task = asyncio.create_task(client.create_assembly(files={"file": upload})) + assembly = client.new_assembly() + assembly.add_file(upload) + task = asyncio.create_task(assembly.create(resumable=False)) try: assert await asyncio.to_thread(started.wait, 5) task.cancel() @@ -116,7 +118,9 @@ async def upload(): if mode == "tus": await assembly._do_tus_upload_async("assembly", "upload", 3) else: - await client.create_assembly(files={"file": stream}) + multipart = client.new_assembly() + multipart.add_file(stream) + await multipart.create(resumable=False) task = asyncio.create_task(upload()) assert await asyncio.to_thread(started.wait, 5) task.cancel() diff --git a/tox.ini b/tox.ini index 2ae97b6..3f3152e 100644 --- a/tox.ini +++ b/tox.ini @@ -7,5 +7,4 @@ deps = pytest-cov>=7.1,<8 requests-mock>=1.12.1,<2 commands = - python scripts/generate_endpoints.py --check pytest tests diff --git a/transloadit/_contract.py b/transloadit/_contract.py deleted file mode 100644 index 573cd3d..0000000 --- a/transloadit/_contract.py +++ /dev/null @@ -1,285 +0,0 @@ -# Generated by scripts/generate_endpoints.py. Do not edit. -CONTRACT = {'capability': {'assemblyField': 'assembly_ssl_url', - 'collectionField': 'tus_url', - 'creationStatus': 201, - 'identityField': 'assembly_id', - 'locationHeader': 'location', - 'metadataHeader': 'upload-metadata', - 'metadataName': 'assembly_url', - 'publicHostPattern': '^api2-(?!xn--)[a-z0-9](?:[a-z0-9-]{0,56}[a-z0-9])?\\.transloadit\\.com$', - 'routes': [{'kind': 'create-assembly', 'parameters': [], 'path': '/assemblies'}, - {'kind': 'status-stream', - 'parameters': [{'name': 'statusStream', - 'pattern': '^ws[0-9]+$', - 'percentDecode': False}], - 'path': '/{statusStream}'}, - {'kind': 'assembly', - 'parameters': [{'name': 'assemblyId', - 'pattern': '^[a-z0-9]{32}$', - 'percentDecode': False}], - 'path': '/assemblies/{assemblyId}'}, - {'kind': 'assembly', - 'parameters': [{'name': 'assemblyId', - 'pattern': '^[a-z0-9]{32}$', - 'percentDecode': False}], - 'path': '/assemblies/{assemblyId}'}, - {'kind': 'create-assembly', - 'parameters': [{'name': 'assemblyId', - 'pattern': '^[a-z0-9]{32}$', - 'percentDecode': False}], - 'path': '/assemblies/{assemblyId}'}, - {'kind': 'tus-collection', 'parameters': [], 'path': '/resumable/files'}, - {'kind': 'tus-collection', 'parameters': [], 'path': '/resumable/files'}, - {'kind': 'tus-upload-resource', - 'parameters': [{'minLength': 1, - 'name': 'uploadId', - 'percentDecode': True}], - 'path': '/resumable/files/{uploadId}'}, - {'kind': 'tus-upload-resource', - 'parameters': [{'minLength': 1, - 'name': 'uploadId', - 'percentDecode': True}], - 'path': '/resumable/files/{uploadId}'}, - {'kind': 'tus-upload-resource', - 'parameters': [{'minLength': 1, - 'name': 'uploadId', - 'percentDecode': True}], - 'path': '/resumable/files/{uploadId}'}, - {'kind': 'tus-upload-resource', - 'parameters': [{'minLength': 1, - 'name': 'uploadId', - 'percentDecode': True}], - 'path': '/resumable/files/{uploadId}'}], - 'streamField': 'update_stream_url', - 'streamQuery': 'assembly', - 'unsupportedHeaders': ['upload-concat', - 'x-http-method-override', - 'x-method-override'], - 'version': 2}, - 'operations': {'api2.assembly-stats': {'method': 'GET', - 'path': '/assembly_stats', - 'python_method': 'assembly_stats', - 'stage': None}, - 'api2.bulk-delete-dam-assets': {'method': 'POST', - 'path': '/dam/assets/bulk/delete', - 'python_method': 'bulk_delete_dam_assets', - 'stage': 'alpha'}, - 'api2.bulk-move-dam-assets': {'method': 'POST', - 'path': '/dam/assets/bulk/move', - 'python_method': 'bulk_move_dam_assets', - 'stage': 'alpha'}, - 'api2.cancel-assembly': {'method': 'DELETE', - 'path': '/assemblies/{assemblyId}', - 'python_method': 'cancel_assembly', - 'stage': None}, - 'api2.create-assembly': {'method': 'POST', - 'path': '/assemblies', - 'python_method': 'create_assembly', - 'stage': None}, - 'api2.create-auth-key': {'method': 'POST', - 'path': '/auth_keys', - 'python_method': 'create_auth_key', - 'stage': None}, - 'api2.create-template': {'method': 'POST', - 'path': '/templates', - 'python_method': 'create_template', - 'stage': None}, - 'api2.create-template-credential': {'method': 'POST', - 'path': '/template_credentials', - 'python_method': 'create_template_credentials', - 'stage': None}, - 'api2.delete-auth-key': {'method': 'DELETE', - 'path': '/auth_keys/{authKeyId}', - 'python_method': 'delete_auth_key', - 'stage': None}, - 'api2.delete-dam-asset': {'method': 'DELETE', - 'path': '/dam/assets/{assetId}', - 'python_method': 'delete_dam_asset', - 'stage': 'alpha'}, - 'api2.delete-template': {'method': 'DELETE', - 'path': '/templates/{templateIdOrName}', - 'python_method': 'delete_template', - 'stage': None}, - 'api2.delete-template-credential': {'method': 'DELETE', - 'path': '/template_credentials/{templateCredentialId}', - 'python_method': 'delete_template_credentials', - 'stage': None}, - 'api2.get-assembly': {'method': 'GET', - 'path': '/assemblies/{assemblyId}', - 'python_method': 'get_assembly', - 'stage': None}, - 'api2.get-bill': {'method': 'GET', - 'path': '/bill/{billYearMonth}', - 'python_method': 'get_bill', - 'stage': None}, - 'api2.get-dam-asset': {'method': 'GET', - 'path': '/dam/assets/{assetId}', - 'python_method': 'get_dam_asset', - 'stage': None}, - 'api2.get-template': {'method': 'GET', - 'path': '/templates/{templateIdOrName}', - 'python_method': 'get_template', - 'stage': None}, - 'api2.get-template-credential': {'method': 'GET', - 'path': '/template_credentials/{templateCredentialId}', - 'python_method': 'get_template_credentials', - 'stage': None}, - 'api2.issue-bearer-token': {'method': 'POST', - 'path': '/token', - 'python_method': 'issue_bearer_token', - 'stage': None}, - 'api2.list-assemblies': {'method': 'GET', - 'path': '/assemblies', - 'python_method': 'list_assemblies', - 'stage': None}, - 'api2.list-assembly-notifications': {'method': 'GET', - 'path': '/assembly_notifications/{assemblyId}', - 'python_method': 'list_assembly_notifications', - 'stage': None}, - 'api2.list-auth-key-scopes': {'method': 'GET', - 'path': '/auth_keys/scopes', - 'python_method': 'list_auth_key_scopes', - 'stage': None}, - 'api2.list-auth-keys': {'method': 'GET', - 'path': '/auth_keys', - 'python_method': 'list_auth_keys', - 'stage': None}, - 'api2.list-dam-assets': {'method': 'GET', - 'path': '/dam/assets', - 'python_method': 'list_dam_assets', - 'stage': None}, - 'api2.list-priority-job-slots': {'method': 'GET', - 'path': '/queues/job_slots', - 'python_method': 'list_priority_job_slots', - 'stage': None}, - 'api2.list-template-credential-types': {'method': 'GET', - 'path': '/template_credentials/types', - 'python_method': 'list_template_credential_types', - 'stage': None}, - 'api2.list-template-credentials': {'method': 'GET', - 'path': '/template_credentials', - 'python_method': 'list_template_credentials', - 'stage': None}, - 'api2.list-templates': {'method': 'GET', - 'path': '/templates', - 'python_method': 'list_templates', - 'stage': None}, - 'api2.move-dam-asset': {'method': 'PATCH', - 'path': '/dam/assets/{assetId}', - 'python_method': 'move_dam_asset', - 'stage': 'alpha'}, - 'api2.move-dam-entry': {'method': 'POST', - 'path': '/dam/entries/move', - 'python_method': 'move_dam_entry', - 'stage': 'alpha'}, - 'api2.priority-job-slot-stats': {'method': 'GET', - 'path': '/priority_job_slot_stats', - 'python_method': 'priority_job_slot_stats', - 'stage': None}, - 'api2.replace-assembly': {'method': 'PUT', - 'path': '/assemblies/{assemblyId}', - 'python_method': 'replace_assembly', - 'stage': None}, - 'api2.replay-assembly': {'method': 'POST', - 'path': '/assemblies/{assemblyId}/replay', - 'python_method': 'replay_assembly', - 'stage': None}, - 'api2.replay-assembly-notification': {'method': 'POST', - 'path': '/assembly_notifications/{assemblyId}/replay', - 'python_method': 'replay_assembly_notification', - 'stage': None}, - 'api2.show-auth-key-secret': {'method': 'POST', - 'path': '/auth_keys/show_secret/{authKeyId}', - 'python_method': 'show_auth_key_secret', - 'stage': None}, - 'api2.stream-assembly-status': {'method': 'GET', - 'path': '/{statusStream}', - 'python_method': 'stream_assembly_status', - 'stage': None}, - 'api2.update-auth-key': {'method': 'PUT', - 'path': '/auth_keys/{authKeyId}', - 'python_method': 'update_auth_key', - 'stage': None}, - 'api2.update-template': {'method': 'PUT', - 'path': '/templates/{templateIdOrName}', - 'python_method': 'update_template', - 'stage': None}, - 'api2.update-template-credential': {'method': 'PUT', - 'path': '/template_credentials/{templateCredentialId}', - 'python_method': 'update_template_credentials', - 'stage': None}, - 'tusd.create-upload': {'method': 'POST', - 'path': '/resumable/files', - 'python_method': 'create_upload', - 'stage': None}, - 'tusd.delete-upload': {'method': 'DELETE', - 'path': '/resumable/files/{uploadId}', - 'python_method': 'delete_upload', - 'stage': None}, - 'tusd.download-upload': {'method': 'GET', - 'path': '/resumable/files/{uploadId}', - 'python_method': 'download_upload', - 'stage': None}, - 'tusd.get-upload-offset': {'method': 'HEAD', - 'path': '/resumable/files/{uploadId}', - 'python_method': 'get_upload_offset', - 'stage': None}, - 'tusd.options': {'method': 'OPTIONS', - 'path': '/resumable/files', - 'python_method': 'tus_options', - 'stage': None}, - 'tusd.patch-upload': {'method': 'PATCH', - 'path': '/resumable/files/{uploadId}', - 'python_method': 'patch_upload', - 'stage': None}}, - 'protocols': {'tusd.create-upload': {'binary_response': False, - 'defaults': {'tus-resumable': '1.0.0'}, - 'destination': 'tus-collection', - 'method': 'POST'}, - 'tusd.delete-upload': {'binary_response': False, - 'defaults': {'tus-resumable': '1.0.0'}, - 'destination': 'tus-upload-resource', - 'method': 'DELETE'}, - 'tusd.download-upload': {'binary_response': True, - 'defaults': {}, - 'destination': 'tus-upload-resource', - 'method': 'GET'}, - 'tusd.get-upload-offset': {'binary_response': False, - 'defaults': {'tus-resumable': '1.0.0'}, - 'destination': 'tus-upload-resource', - 'method': 'HEAD'}, - 'tusd.options': {'binary_response': False, - 'defaults': {}, - 'destination': 'tus-collection', - 'method': 'OPTIONS'}, - 'tusd.patch-upload': {'binary_response': False, - 'defaults': {'content-type': 'application/offset+octet-stream', - 'tus-resumable': '1.0.0'}, - 'destination': 'tus-upload-resource', - 'method': 'PATCH'}}, - 'stream_events': [{'data': {'$ref': 'urn:transloadit:json-schema:sha256:de7f1223b1c85e19c68ce352fd4ab3febf036a5465c18990d5220a9141770ba8'}, - 'kind': 'event', - 'name': 'assembly_error', - 'terminal': True}, - {'data': {'$ref': 'urn:transloadit:json-schema:sha256:0c63aba5703f317c14e15fc6ee66a489b19331fb048d1673c1f36214fc1fb1dd'}, - 'kind': 'event', - 'name': 'assembly_execution_progress', - 'terminal': False}, - {'kind': 'message', 'name': 'assembly_finished', 'terminal': True}, - {'kind': 'message', 'name': 'ping', 'terminal': False}, - {'data': {'$ref': 'urn:transloadit:json-schema:sha256:dee4880f0fa9a16a80f73b4c01c4613db2bbf83180a2d1ca7726274e619cd05e'}, - 'kind': 'event', - 'name': 'assembly_result_finished', - 'terminal': False}, - {'data': {'$ref': 'urn:transloadit:json-schema:sha256:87244e853c1392a3d720076fd5f9bba476473de64a010e876b589407191efe87'}, - 'kind': 'event', - 'name': 'assembly_upload_finished', - 'terminal': False}, - {'kind': 'message', - 'name': 'assembly_upload_meta_data_extracted', - 'terminal': False}, - {'kind': 'message', 'name': 'assembly_uploading_finished', 'terminal': False}], - 'token_auth': {'field': 'grant_type', - 'values': {'authorization_code': 'none', - 'client_credentials': 'basic', - 'refresh_token': 'none'}}} diff --git a/transloadit/api_url.py b/transloadit/api_url.py index 48edcce..2c3a92f 100644 --- a/transloadit/api_url.py +++ b/transloadit/api_url.py @@ -1,12 +1,10 @@ import re from urllib.parse import urlparse -from ._contract import CONTRACT - def is_transloadit_api_host(hostname): hostname = (hostname or "").lower() - return hostname == "api2.transloadit.com" or re.fullmatch(CONTRACT["capability"]["publicHostPattern"], hostname) is not None + return hostname == "api2.transloadit.com" or re.fullmatch(r"api2-(?!xn--)[a-z0-9](?:[a-z0-9-]{0,56}[a-z0-9])?\.transloadit\.com", hostname) is not None def normalize_service_url(service): diff --git a/transloadit/assembly.py b/transloadit/assembly.py index b4dbcb7..5dbfdad 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -86,8 +86,7 @@ def _rewind_files(self, positions): raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc def _do_tus_upload(self, assembly_url, tus_url, retries): - # Preserve legacy custom/Gateway upload hosts returned by the configured - # service. Contract capability restrictions apply to the raw TUS methods. + # Preserve custom/Gateway upload hosts returned by the configured service. tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): metadata = { diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index e2f4c20..c3c12db 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -63,8 +63,7 @@ def _rewind_files(self, positions): raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc def _do_tus_upload(self, assembly_url, tus_url, retries): - # Preserve legacy custom/Gateway upload hosts returned by the configured - # service. Contract capability restrictions apply to the raw TUS methods. + # Preserve custom/Gateway upload hosts returned by the configured service. tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): filename = get_upload_filename(file_stream, key) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 9a9bc26..e5d39b8 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -4,7 +4,6 @@ from . import async_assembly, async_request, async_template from .api_url import is_transloadit_api_host, normalize_service_url, require_path_id -from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url @@ -20,14 +19,11 @@ def __init__( service: str = "https://api2.transloadit.com", duration: int = 300, session=None, - *, - bearer_token: str = None, ): self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration - self.bearer_token = bearer_token self.request = async_request.AsyncRequest(self, session=session) async def __aenter__(self): @@ -49,7 +45,6 @@ def new_assembly(self, params: dict = None) -> async_assembly.AsyncAssembly: """ return async_assembly.AsyncAssembly(self, options=params) - # Compatibility aliases and capability URL handling are maintained by hand. def _quote_path_segment(self, value: str) -> str: value = str(value) if value in (".", ".."): @@ -114,530 +109,114 @@ async def _request_assembly_url(self, url, method, params=None): return await self.request.public(method, candidate_url, params=params) - async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): + async def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Create an Assembly with a chosen ID. - """ - assembly_id = require_path_id(assembly_id, "assembly_id") - - return await self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) - - async def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): - """ - Retrieve an invoice’s bill. - """ - date = require_path_id(date, "date") - invoice_id = require_path_id(invoice_id, "invoice_id") - - return await self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) - - async def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): - """ - Retrieve full Template details. - """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - - return await self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) - - async def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): - """ - Retrieve full built-in Template details. - """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - - return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) - - async def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): - """ - Retrieve a built-in Template. - """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - - return await self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) - - async def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): - """ - Validate an OAuth Template Credential name. - """ - return await self.request.post("/template_credentials/validateOauthOnCreate", data=data) - - # - # Generated by scripts/generate_endpoints.py; edit the generator, not this block. + Get the assembly specified by the 'assembly_id' or the 'assembly_url' + Either the assembly_id or the assembly_url must be specified - async def assembly_stats(self, params=None): - """ - Retrieve Assembly statistics - - Contract operation: api2.assembly-stats. - """ - return await self.request.get('/assembly_stats', params=params) - - async def bulk_delete_dam_assets(self, data=None): - """ - Delete DAM assets in bulk - - Contract operation: api2.bulk-delete-dam-assets. - Stage: alpha; this API may change. - """ - return await self.request.post('/dam/assets/bulk/delete', data=data) - - async def bulk_move_dam_assets(self, data=None): - """ - Move DAM assets in bulk - - Contract operation: api2.bulk-move-dam-assets. - Stage: alpha; this API may change. - """ - return await self.request.post('/dam/assets/bulk/move', data=data) + :Args: + - assembly_id (Optional[str]) + - assembly_url (Optional[str]) - async def cancel_assembly(self, assembly_id=None, assembly_url=None): - """ - Cancel a running Assembly - - Contract operation: api2.cancel-assembly. + Return an instance of """ if not (assembly_id or assembly_url): - raise ValueError("Either assembly_id or assembly_url is required.") - url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return await self._request_assembly_url(url, 'DELETE') - - async def create_assembly(self, data=None, extra_data=None, files=None): - """ - Create a new Assembly - - Contract operation: api2.create-assembly. - """ - return await self.request.post('/assemblies', data=data, extra_data=extra_data, files=files) - - async def create_auth_key(self, data=None): - """ - Create a new Auth Key - - Contract operation: api2.create-auth-key. - """ - return await self.request.post('/auth_keys', data=data) + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - async def create_template(self, data=None): - """ - Create a new Template - - Contract operation: api2.create-template. - """ - return await self.request.post('/templates', data=data) - - async def create_template_credentials(self, data=None): - """ - Create a new Template Credential - - Contract operation: api2.create-template-credential. - """ - return await self.request.post('/template_credentials', data=data) - - async def delete_auth_key(self, auth_key_id: str, data=None): - """ - Delete an Auth Key - - Contract operation: api2.delete-auth-key. - """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return await self.request.delete(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) - - async def delete_dam_asset(self, asset_id: str, data=None): - """ - Delete a DAM asset - - Contract operation: api2.delete-dam-asset. - Stage: alpha; this API may change. - """ - asset_id = require_path_id(asset_id, 'asset_id') - return await self.request.delete(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - - async def delete_template(self, template_id: str, data=None): - """ - Delete a Template - - Contract operation: api2.delete-template. - """ - template_id = require_path_id(template_id, 'template_id') - return await self.request.delete(f'/templates/{self._quote_path_segment(template_id)}', data=data) - - async def delete_template_credentials(self, identifier: str, data=None): - """ - Delete a Template Credential - - Contract operation: api2.delete-template-credential. - """ - identifier = require_path_id(identifier, 'identifier') - return await self.request.delete(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) - - async def get_assembly(self, assembly_id=None, assembly_url=None, params=None): - """ - Retrieve an Assembly Status - - Contract operation: api2.get-assembly. - """ - if not (assembly_id or assembly_url): - raise ValueError("Either assembly_id or assembly_url is required.") url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return await self._request_assembly_url(url, 'GET', params=params) + return await self._request_assembly_url(url, "GET") - async def get_bill(self, month: int, year: int, params=None): + async def list_assemblies(self, params: dict = None): """ - Retrieve a month’s bill + Get the list of assemblies. - Contract operation: api2.get-bill. - """ - return await self.request.get(f'/bill/{year}-{month:02d}', params=params) + :Args: + - options (Optional[dict]): + params to send along with the request. Please see + https://transloadit.com/docs/api-docs/#25-retrieve-assembly-list for available options. - async def get_dam_asset(self, asset_id: str, params=None): + Return an instance of """ - Retrieve a Storage asset + return await self.request.get("/assemblies", params=params) - Contract operation: api2.get-dam-asset. + async def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - asset_id = require_path_id(asset_id, 'asset_id') - return await self.request.get(f'/dam/assets/{self._quote_path_segment(asset_id)}', params=params) + Cancel the assembly specified by the 'assembly_id' or the 'assembly_url' + Either the assembly_id or the assembly_url must be specified - async def get_template(self, template_id: str, params=None): - """ - Retrieve a Template + :Args: + - assembly_id (Optional[str]) + - assembly_url (Optional[str]) - Contract operation: api2.get-template. + Return an instance of """ - template_id = require_path_id(template_id, 'template_id') - return await self.request.get(f'/templates/{self._quote_path_segment(template_id)}', params=params) - - async def get_template_credentials(self, identifier: str, params=None): - """ - Retrieve a Template Credential - - Contract operation: api2.get-template-credential. - """ - identifier = require_path_id(identifier, 'identifier') - return await self.request.get(f'/template_credentials/{self._quote_path_segment(identifier)}', params=params) - - async def issue_bearer_token(self, data=None): - """ - Create a bearer token - - Contract operation: api2.issue-bearer-token. - """ - return await self.request.issue_bearer_token(data) - - async def list_assemblies(self, params=None): - """ - Retrieve list of Assemblies - - Contract operation: api2.list-assemblies. - """ - return await self.request.get('/assemblies', params=params) - - async def list_assembly_notifications(self, assembly_id: str, params=None): - """ - Retrieve Assembly Notifications - - Contract operation: api2.list-assembly-notifications. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return await self.request.public('GET', f'/assembly_notifications/{self._quote_path_segment(assembly_id)}', params=params) - - async def list_auth_key_scopes(self, params=None): - """ - Retrieve Auth Key scopes - - Contract operation: api2.list-auth-key-scopes. - """ - return await self.request.get('/auth_keys/scopes', params=params) - - async def list_auth_keys(self, params=None): - """ - Retrieve list of Auth Keys - - Contract operation: api2.list-auth-keys. - """ - return await self.request.get('/auth_keys', params=params) - - async def list_dam_assets(self, params=None): - """ - List Storage assets - - Contract operation: api2.list-dam-assets. - """ - return await self.request.get('/dam/assets', params=params) - - async def list_priority_job_slots(self, params=None): - """ - Retrieve currently used priority job slots - - Contract operation: api2.list-priority-job-slots. - """ - return await self.request.get('/queues/job_slots', params=params) - - async def list_template_credential_types(self, params=None): - """ - Retrieve Template Credential types - - Contract operation: api2.list-template-credential-types. - """ - return await self.request.get('/template_credentials/types', params=params) - - async def list_template_credentials(self, params=None): - """ - Retrieve list of Template Credentials - - Contract operation: api2.list-template-credentials. - """ - return await self.request.get('/template_credentials', params=params) - - async def list_templates(self, params=None): - """ - Retrieve list of Templates - - Contract operation: api2.list-templates. - """ - return await self.request.get('/templates', params=params) - - async def move_dam_asset(self, asset_id: str, data=None): - """ - Move or rename a DAM asset - - Contract operation: api2.move-dam-asset. - Stage: alpha; this API may change. - """ - asset_id = require_path_id(asset_id, 'asset_id') - return await self.request.patch(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - - async def move_dam_entry(self, data=None): - """ - Move a Storage file or folder - - Contract operation: api2.move-dam-entry. - Stage: alpha; this API may change. - """ - return await self.request.post('/dam/entries/move', data=data) - - async def priority_job_slot_stats(self, params=None): - """ - Retrieve priority job slot statistics - - Contract operation: api2.priority-job-slot-stats. - """ - return await self.request.get('/priority_job_slot_stats', params=params) - - async def replace_assembly(self, assembly_id: str, data=None, extra_data=None, files=None): - """ - Create an Assembly with a supplied ID - - Contract operation: api2.replace-assembly. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return await self.request.put(f'/assemblies/{self._quote_path_segment(assembly_id)}', data=data, extra_data=extra_data, files=files) - - async def replay_assembly(self, assembly_id: str, data=None): - """ - Replay an Assembly - - Contract operation: api2.replay-assembly. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return await self.request.post(f'/assemblies/{self._quote_path_segment(assembly_id)}/replay', data=data) - - async def replay_assembly_notification(self, assembly_id: str, data=None): - """ - Replay Assembly Notification - - Contract operation: api2.replay-assembly-notification. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return await self.request.post(f'/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay', data=data) - - async def show_auth_key_secret(self, auth_key_id: str, data=None): - """ - Retrieve an Auth Key secret - - Contract operation: api2.show-auth-key-secret. - """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return await self.request.post(f'/auth_keys/show_secret/{self._quote_path_segment(auth_key_id)}', data=data) - - def stream_assembly_status(self, stream_url, *, read_timeout=120, max_event_size=1048576): - """ - Stream Assembly changes live - - Contract operation: api2.stream-assembly-status. - Use with a context manager. Terminal events do not imply Assembly success. - """ - return self.request.stream_status(stream_url, read_timeout=read_timeout, max_event_size=max_event_size) - - async def update_auth_key(self, auth_key_id: str, data=None): - """ - Edit an Auth Key + if not (assembly_id or assembly_url): + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - Contract operation: api2.update-auth-key. - """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return await self.request.put(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" + return await self._request_assembly_url(url, "DELETE") - async def update_template(self, template_id: str, data=None): + async def get_template(self, template_id: str): """ - Edit a Template + Get the template specified by the 'template_id'. - Contract operation: api2.update-template. - """ - template_id = require_path_id(template_id, 'template_id') - return await self.request.put(f'/templates/{self._quote_path_segment(template_id)}', data=data) + :Args: + - template_id (str) - async def update_template_credentials(self, identifier: str, data=None): + Return an instance of """ - Edit a Template Credential + template_id = require_path_id(template_id, "template_id") + return await self.request.get(f"/templates/{self._quote_path_segment(template_id)}") - Contract operation: api2.update-template-credential. + async def list_templates(self, params: Optional[dict] = None): """ - identifier = require_path_id(identifier, 'identifier') - return await self.request.put(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) + Get the list of templates. - async def create_upload(self, assembly, headers=None, body=None): - """ - Create a tus upload + :Args: + - options (Optional[dict]): + params to send along with the request. Please see + https://transloadit.com/docs/api-docs/#45-retrieve-template-list for available options. - Contract operation: tusd.create-upload. - Pass protocol headers using headers; binary downloads return bytes. + Return an instance of """ - return await self.request.tus('tusd.create-upload', assembly, headers=headers, body=body) + return await self.request.get("/templates", params=params) - async def delete_upload(self, upload_url, headers=None): + async def update_template(self, template_id: str, data: dict): """ - Terminate a tus upload + Update the template specified by the 'template_id'. - Contract operation: tusd.delete-upload. - Pass protocol headers using headers; binary downloads return bytes. - """ - return await self.request.tus('tusd.delete-upload', upload_url, headers=headers, body=None) + :Args: + - template_id (str) + - data (dict): key, value pair of fields and their new values. - async def download_upload(self, upload_url, headers=None): + Return an instance of """ - Download a tus upload + template_id = require_path_id(template_id, "template_id") + return await self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) - Contract operation: tusd.download-upload. - Pass protocol headers using headers; binary downloads return bytes. + async def delete_template(self, template_id: str): """ - return await self.request.tus('tusd.download-upload', upload_url, headers=headers, body=None) + Delete the template specified by the 'template_id'. - async def get_upload_offset(self, upload_url, headers=None): - """ - Retrieve a tus upload offset + :Args: + - template_id (str) - Contract operation: tusd.get-upload-offset. - Pass protocol headers using headers; binary downloads return bytes. + Return an instance of """ - return await self.request.tus('tusd.get-upload-offset', upload_url, headers=headers, body=None) + template_id = require_path_id(template_id, "template_id") + return await self.request.delete(f"/templates/{self._quote_path_segment(template_id)}") - async def tus_options(self, assembly, headers=None): + async def get_bill(self, month: int, year: int): """ - Discover tus capabilities + Get the bill for the specified month and year. - Contract operation: tusd.options. - Pass protocol headers using headers; binary downloads return bytes. - """ - return await self.request.tus('tusd.options', assembly, headers=headers, body=None) + :Args: + - month (int): e.g 1 for January + - year (int) - async def patch_upload(self, upload_url, headers=None, body=None): + Return an instance of """ - Upload tus file bytes - - Contract operation: tusd.patch-upload. - Pass protocol headers using headers; binary downloads return bytes. - """ - return await self.request.tus('tusd.patch-upload', upload_url, headers=headers, body=body) - # - - # High-level upload/resume workflows are maintained by hand. - - async def create_tus_assembly(self, file_count: int): - """ - Creates a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. - """ - assembly = await self.create_assembly( - data={ - "await": False, - "steps": { - ":original": { - "output_meta": True, - "result": "debug", - "robot": "/upload/handle", - }, - }, - }, - extra_data={ - "num_expected_upload_files": file_count, - }, - ) - - return assembly - - async def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): - """Resume from the reported offset, then poll the Assembly to completion.""" - offset_response = await self.get_upload_offset(upload_url) - if offset_response.status_code != 200: - raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}") - try: - offset = int(offset_response.headers.get("Upload-Offset", "")) - except ValueError: - raise RuntimeError("TUS offset is not an integer.") from None - if not 0 <= offset <= len(content): - raise RuntimeError("TUS offset is outside the supplied content.") - response = await self.patch_upload(upload_url, headers={"Upload-Offset": str(offset)}, body=content[offset:]) - if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): - raise RuntimeError("TUS resume did not acknowledge the complete content.") - return await self.wait_for_assembly(assembly_ssl_url) - - async def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): - """Create an Assembly, upload one file using TUS, and wait for completion.""" - encoded = encode_upload_metadata(fieldname, filename, user_meta) - assembly = await self.create_tus_assembly(1) - check_assembly_created(assembly) - created = await self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) - if created.status_code != 201: - raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") - response = await self.patch_upload(created.upload_url, headers={"Upload-Offset": "0"}, body=content) - if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): - raise RuntimeError("TUS upload did not acknowledge the complete content.") - completed = await self.wait_for_assembly(assembly.data["assembly_ssl_url"]) - return completed, created.upload_url - - async def wait_for_assembly(self, assembly_url: str, *, retries=3): - """ - Waits for an Assembly to finish uploading and executing. - Use the returned assembly_ssl_url as the assembly URL. - Retry consecutive rate limits up to retries times, honoring info.retryIn. - """ - if not isinstance(retries, int) or retries < 0: - raise ValueError("retries must be a non-negative integer.") - polling = self.new_assembly() - remaining = retries - while True: - response = await self.get_assembly(assembly_url=assembly_url) - data = response.data - - if not isinstance(data, dict): - raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") - - if polling._rate_limit_reached(data): - if remaining == 0: - return response - remaining -= 1 - await asyncio.sleep(polling._retry_delay(data)) - continue - remaining = retries - if data.get("error"): - return response - - # The polling is done if the assembly is not uploading or executing anymore. - if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING", "ASSEMBLY_REPLAYING"): - return response - - await asyncio.sleep(1) - + return await self.request.get(f"/bill/{year}-{month:02d}") def new_template(self, name: str, params: Optional[dict] = None) -> async_template.AsyncTemplate: """ diff --git a/transloadit/async_request.py b/transloadit/async_request.py index ec83d65..bf2a977 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -16,9 +16,8 @@ from . import __version__ from .api_url import should_sign_api_url -from .endpoint_transport import async_network_options, capability_url, token_request, tus_request, validate_upload_location +from .network import async_network_options from .response import Response -from .stream import EventParser, StreamError from .upload import get_upload_filename, run_upload_worker TIMEOUT = 60 @@ -118,27 +117,15 @@ def __init__(self, transloadit, session=None): def session(self): return self._session - def _headers(self, url=None): - headers = dict(self.HEADERS) - if url and getattr(self.transloadit, "bearer_token", None) and should_sign_api_url(url, self.transloadit.service): - headers["Authorization"] = "Bearer " + self.transloadit.bearer_token - return headers + def _headers(self): + return dict(self.HEADERS) @asynccontextmanager async def _api_session(self, url): - if "Authorization" in self._headers(url): - # Explicit bearer auth wins over netrc and injected account defaults. - async with self._isolated_session() as session: - yield session - else: - yield await self._ensure_session() + yield await self._ensure_session() async def _request_options(self, url): - headers = self._headers(url) - options = {"headers": headers, "timeout": self._timeout(), "allow_redirects": False} - if "Authorization" in headers: - options.update(await async_network_options(url, self._session)) - return options + return {"headers": self._headers(), "timeout": self._timeout(), "allow_redirects": False} def _get_session_lock(self): if self._session_lock is None: @@ -273,9 +260,6 @@ async def put(self, path, data=None, extra_data=None, files=None): """ return await self._form_request("put", path, data, extra_data, files) - async def patch(self, path, data=None): - return await self._form_request("patch", path, data) - async def delete(self, path, data=None): """ Makes an asynchronous HTTP DELETE request. @@ -295,8 +279,6 @@ async def delete(self, path, data=None): def _to_payload(self, data): data = copy.deepcopy(data or {}) - if getattr(self.transloadit, "bearer_token", None): - return {"params": json.dumps(data)} expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) if "auth" in data and not isinstance(data["auth"], dict): raise ValueError("auth must be a dictionary when provided.") @@ -337,7 +319,7 @@ async def _isolated_session(self): async def public(self, method, path, params=None, data=None): # A separate session prevents injected session cookies/auth from leaking - # onto credential-free capability and public endpoints. + # onto credential-free Assembly capability requests. url = self._get_full_url(path) async with self._isolated_session() as session: async with session.request(method, url, params=params, data=data, @@ -345,48 +327,3 @@ async def public(self, method, path, params=None, data=None): **(await async_network_options(url, self._session))) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) - - async def issue_bearer_token(self, data=None): - url, data, headers = token_request(self.transloadit, data) - headers.update(self._headers()) - async with self._isolated_session() as session: - async with session.post(url, data=self._normalize_payload(data), headers=headers, - timeout=self._timeout(), allow_redirects=False, **(await async_network_options(url, self._session))) as response: - return Response(data=await self._read_response_data(response), status_code=response.status, - headers=CaseInsensitiveDict(response.headers)) - - async def tus(self, operation_id, location, headers=None, body=None): - spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) - headers.update(self._headers()) - async with self._isolated_session() as session: - async with session.request(spec["method"], url, data=body, headers=headers, - timeout=self._timeout(), allow_redirects=False, **(await async_network_options(url, self._session))) as raw: - data = await raw.read() if spec["binary_response"] else await self._read_response_data(raw) - response = Response(data=data, status_code=raw.status, headers=CaseInsensitiveDict(raw.headers)) - if spec["method"] == "POST": - validate_upload_location(self.transloadit, url, response) - return response - - @asynccontextmanager - async def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): - url = capability_url(self.transloadit, url, "status-stream") - parser = EventParser(max_event_size) - timeout = aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=read_timeout) - async with self._isolated_session() as session: - async with session.get(url, headers={**self._headers(), "Accept": "text/event-stream"}, - timeout=timeout, allow_redirects=False, **(await async_network_options(url, self._session))) as response: - if response.status != 200: - raise StreamError(response.status) - if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": - raise StreamError(response.status, "Expected text/event-stream") - - async def events(): - # EOF is not Assembly success; callers inspect the final status. - # Keep aiohttp exception types for existing retry policies. - async for chunk in response.content.iter_any(): - for event in parser.feed(chunk): - yield event - if event.terminal: - return - - yield events() diff --git a/transloadit/client.py b/transloadit/client.py index e5c22d2..3cb1351 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -1,13 +1,9 @@ import typing -from time import sleep from typing import Optional from urllib.parse import quote -import requests - from . import assembly, request, template from .api_url import is_transloadit_api_host, normalize_service_url, require_path_id -from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url if typing.TYPE_CHECKING: @@ -42,14 +38,11 @@ def __init__( auth_secret: str, service: str = "https://api2.transloadit.com", duration: int = 300, - *, - bearer_token: str = None, ): self.service = normalize_service_url(service) self.auth_key = auth_key self.auth_secret = auth_secret self.duration = duration - self.bearer_token = bearer_token self.request = request.Request(self) def new_assembly(self, params: dict = None) -> assembly.Assembly: @@ -59,7 +52,6 @@ def new_assembly(self, params: dict = None) -> assembly.Assembly: """ return assembly.Assembly(self, options=params) - # Compatibility aliases and capability URL handling are maintained by hand. def _quote_path_segment(self, value: str) -> str: value = str(value) if value in (".", ".."): @@ -124,530 +116,114 @@ def _request_assembly_url(self, url, method, params=None): return self.request.public(method, candidate_url, params=params) - def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): - """ - Create an Assembly with a chosen ID. - """ - assembly_id = require_path_id(assembly_id, "assembly_id") - - return self.request.post(f"/assemblies/{self._quote_path_segment(assembly_id)}", data=data, extra_data=extra_data, files=files) - - def get_bill_for_invoice(self, date: str, invoice_id: str, params: Optional[dict] = None): - """ - Retrieve an invoice’s bill. - """ - date = require_path_id(date, "date") - invoice_id = require_path_id(invoice_id, "invoice_id") - - return self.request.get(f"/bill/{self._quote_path_segment(date)}/{self._quote_path_segment(invoice_id)}", params=params) - - def get_template_full(self, template_id_or_name: str, params: Optional[dict] = None): - """ - Retrieve full Template details. - """ - template_id_or_name = require_path_id(template_id_or_name, "template_id_or_name") - - return self.request.get(f"/templates/{self._quote_path_segment(template_id_or_name)}/full", params=params) - - def get_builtin_template_full(self, builtin_template_slug: str, params: Optional[dict] = None): - """ - Retrieve full built-in Template details. - """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - - return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}/full", params=params) - - def get_builtin_template(self, builtin_template_slug: str, params: Optional[dict] = None): - """ - Retrieve a built-in Template. - """ - builtin_template_slug = require_path_id(builtin_template_slug, "builtin_template_slug") - - return self.request.get(f"/templates/builtin/{self._quote_path_segment(builtin_template_slug)}", params=params) - - def validate_template_credential_oauth_on_create(self, data: Optional[dict] = None): - """ - Validate an OAuth Template Credential name. - """ - return self.request.post("/template_credentials/validateOauthOnCreate", data=data) - - # - # Generated by scripts/generate_endpoints.py; edit the generator, not this block. - - def assembly_stats(self, params=None): - """ - Retrieve Assembly statistics - - Contract operation: api2.assembly-stats. - """ - return self.request.get('/assembly_stats', params=params) - - def bulk_delete_dam_assets(self, data=None): - """ - Delete DAM assets in bulk - - Contract operation: api2.bulk-delete-dam-assets. - Stage: alpha; this API may change. - """ - return self.request.post('/dam/assets/bulk/delete', data=data) - - def bulk_move_dam_assets(self, data=None): - """ - Move DAM assets in bulk - - Contract operation: api2.bulk-move-dam-assets. - Stage: alpha; this API may change. + def get_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - return self.request.post('/dam/assets/bulk/move', data=data) + Get the assembly specified by the 'assembly_id' or the 'assembly_url' + Either the assembly_id or the assembly_url must be specified - def cancel_assembly(self, assembly_id=None, assembly_url=None): - """ - Cancel a running Assembly + :Args: + - assembly_id (Optional[str]) + - assembly_url (Optional[str]) - Contract operation: api2.cancel-assembly. + Return an instance of """ if not (assembly_id or assembly_url): - raise ValueError("Either assembly_id or assembly_url is required.") - url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return self._request_assembly_url(url, 'DELETE') - - def create_assembly(self, data=None, extra_data=None, files=None): - """ - Create a new Assembly - - Contract operation: api2.create-assembly. - """ - return self.request.post('/assemblies', data=data, extra_data=extra_data, files=files) - - def create_auth_key(self, data=None): - """ - Create a new Auth Key - - Contract operation: api2.create-auth-key. - """ - return self.request.post('/auth_keys', data=data) + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - def create_template(self, data=None): - """ - Create a new Template - - Contract operation: api2.create-template. - """ - return self.request.post('/templates', data=data) - - def create_template_credentials(self, data=None): - """ - Create a new Template Credential - - Contract operation: api2.create-template-credential. - """ - return self.request.post('/template_credentials', data=data) - - def delete_auth_key(self, auth_key_id: str, data=None): - """ - Delete an Auth Key - - Contract operation: api2.delete-auth-key. - """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return self.request.delete(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) - - def delete_dam_asset(self, asset_id: str, data=None): - """ - Delete a DAM asset - - Contract operation: api2.delete-dam-asset. - Stage: alpha; this API may change. - """ - asset_id = require_path_id(asset_id, 'asset_id') - return self.request.delete(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - - def delete_template(self, template_id: str, data=None): - """ - Delete a Template - - Contract operation: api2.delete-template. - """ - template_id = require_path_id(template_id, 'template_id') - return self.request.delete(f'/templates/{self._quote_path_segment(template_id)}', data=data) - - def delete_template_credentials(self, identifier: str, data=None): - """ - Delete a Template Credential - - Contract operation: api2.delete-template-credential. - """ - identifier = require_path_id(identifier, 'identifier') - return self.request.delete(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) - - def get_assembly(self, assembly_id=None, assembly_url=None, params=None): - """ - Retrieve an Assembly Status - - Contract operation: api2.get-assembly. - """ - if not (assembly_id or assembly_url): - raise ValueError("Either assembly_id or assembly_url is required.") url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" - return self._request_assembly_url(url, 'GET', params=params) - - def get_bill(self, month: int, year: int, params=None): - """ - Retrieve a month’s bill - - Contract operation: api2.get-bill. - """ - return self.request.get(f'/bill/{year}-{month:02d}', params=params) - - def get_dam_asset(self, asset_id: str, params=None): - """ - Retrieve a Storage asset - - Contract operation: api2.get-dam-asset. - """ - asset_id = require_path_id(asset_id, 'asset_id') - return self.request.get(f'/dam/assets/{self._quote_path_segment(asset_id)}', params=params) - - def get_template(self, template_id: str, params=None): - """ - Retrieve a Template - - Contract operation: api2.get-template. - """ - template_id = require_path_id(template_id, 'template_id') - return self.request.get(f'/templates/{self._quote_path_segment(template_id)}', params=params) - - def get_template_credentials(self, identifier: str, params=None): - """ - Retrieve a Template Credential - - Contract operation: api2.get-template-credential. - """ - identifier = require_path_id(identifier, 'identifier') - return self.request.get(f'/template_credentials/{self._quote_path_segment(identifier)}', params=params) - - def issue_bearer_token(self, data=None): - """ - Create a bearer token - - Contract operation: api2.issue-bearer-token. - """ - return self.request.issue_bearer_token(data) - - def list_assemblies(self, params=None): - """ - Retrieve list of Assemblies - - Contract operation: api2.list-assemblies. - """ - return self.request.get('/assemblies', params=params) - - def list_assembly_notifications(self, assembly_id: str, params=None): - """ - Retrieve Assembly Notifications - - Contract operation: api2.list-assembly-notifications. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return self.request.public('GET', f'/assembly_notifications/{self._quote_path_segment(assembly_id)}', params=params) - - def list_auth_key_scopes(self, params=None): - """ - Retrieve Auth Key scopes - - Contract operation: api2.list-auth-key-scopes. - """ - return self.request.get('/auth_keys/scopes', params=params) - - def list_auth_keys(self, params=None): - """ - Retrieve list of Auth Keys - - Contract operation: api2.list-auth-keys. - """ - return self.request.get('/auth_keys', params=params) - - def list_dam_assets(self, params=None): - """ - List Storage assets - - Contract operation: api2.list-dam-assets. - """ - return self.request.get('/dam/assets', params=params) + return self._request_assembly_url(url, "GET") - def list_priority_job_slots(self, params=None): + def list_assemblies(self, params: dict = None): """ - Retrieve currently used priority job slots + Get the list of assemblies. - Contract operation: api2.list-priority-job-slots. - """ - return self.request.get('/queues/job_slots', params=params) - - def list_template_credential_types(self, params=None): - """ - Retrieve Template Credential types - - Contract operation: api2.list-template-credential-types. - """ - return self.request.get('/template_credentials/types', params=params) - - def list_template_credentials(self, params=None): - """ - Retrieve list of Template Credentials - - Contract operation: api2.list-template-credentials. - """ - return self.request.get('/template_credentials', params=params) - - def list_templates(self, params=None): - """ - Retrieve list of Templates - - Contract operation: api2.list-templates. - """ - return self.request.get('/templates', params=params) - - def move_dam_asset(self, asset_id: str, data=None): - """ - Move or rename a DAM asset - - Contract operation: api2.move-dam-asset. - Stage: alpha; this API may change. - """ - asset_id = require_path_id(asset_id, 'asset_id') - return self.request.patch(f'/dam/assets/{self._quote_path_segment(asset_id)}', data=data) - - def move_dam_entry(self, data=None): - """ - Move a Storage file or folder - - Contract operation: api2.move-dam-entry. - Stage: alpha; this API may change. - """ - return self.request.post('/dam/entries/move', data=data) - - def priority_job_slot_stats(self, params=None): - """ - Retrieve priority job slot statistics - - Contract operation: api2.priority-job-slot-stats. - """ - return self.request.get('/priority_job_slot_stats', params=params) - - def replace_assembly(self, assembly_id: str, data=None, extra_data=None, files=None): - """ - Create an Assembly with a supplied ID - - Contract operation: api2.replace-assembly. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return self.request.put(f'/assemblies/{self._quote_path_segment(assembly_id)}', data=data, extra_data=extra_data, files=files) - - def replay_assembly(self, assembly_id: str, data=None): - """ - Replay an Assembly - - Contract operation: api2.replay-assembly. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return self.request.post(f'/assemblies/{self._quote_path_segment(assembly_id)}/replay', data=data) - - def replay_assembly_notification(self, assembly_id: str, data=None): - """ - Replay Assembly Notification - - Contract operation: api2.replay-assembly-notification. - """ - assembly_id = require_path_id(assembly_id, 'assembly_id') - return self.request.post(f'/assembly_notifications/{self._quote_path_segment(assembly_id)}/replay', data=data) - - def show_auth_key_secret(self, auth_key_id: str, data=None): - """ - Retrieve an Auth Key secret - - Contract operation: api2.show-auth-key-secret. - """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return self.request.post(f'/auth_keys/show_secret/{self._quote_path_segment(auth_key_id)}', data=data) - - def stream_assembly_status(self, stream_url, *, read_timeout=120, max_event_size=1048576): - """ - Stream Assembly changes live - - Contract operation: api2.stream-assembly-status. - Use with a context manager. Terminal events do not imply Assembly success. - """ - return self.request.stream_status(stream_url, read_timeout=read_timeout, max_event_size=max_event_size) - - def update_auth_key(self, auth_key_id: str, data=None): - """ - Edit an Auth Key + :Args: + - options (Optional[dict]): + params to send along with the request. Please see + https://transloadit.com/docs/api-docs/#25-retrieve-assembly-list for available options. - Contract operation: api2.update-auth-key. + Return an instance of """ - auth_key_id = require_path_id(auth_key_id, 'auth_key_id') - return self.request.put(f'/auth_keys/{self._quote_path_segment(auth_key_id)}', data=data) + return self.request.get("/assemblies", params=params) - def update_template(self, template_id: str, data=None): + def cancel_assembly(self, assembly_id: str = None, assembly_url: str = None): """ - Edit a Template + Cancel the assembly specified by the 'assembly_id' or the 'assembly_url' + Either the assembly_id or the assembly_url must be specified - Contract operation: api2.update-template. - """ - template_id = require_path_id(template_id, 'template_id') - return self.request.put(f'/templates/{self._quote_path_segment(template_id)}', data=data) + :Args: + - assembly_id (Optional[str]) + - assembly_url (Optional[str]) - def update_template_credentials(self, identifier: str, data=None): + Return an instance of """ - Edit a Template Credential + if not (assembly_id or assembly_url): + raise ValueError("Either 'assembly_id' or 'assembly_url' cannot be None.") - Contract operation: api2.update-template-credential. - """ - identifier = require_path_id(identifier, 'identifier') - return self.request.put(f'/template_credentials/{self._quote_path_segment(identifier)}', data=data) + url = assembly_url if assembly_url else f"/assemblies/{self._quote_path_segment(assembly_id)}" + return self._request_assembly_url(url, "DELETE") - def create_upload(self, assembly, headers=None, body=None): + def get_template(self, template_id: str): """ - Create a tus upload + Get the template specified by the 'template_id'. - Contract operation: tusd.create-upload. - Pass protocol headers using headers; binary downloads return bytes. - """ - return self.request.tus('tusd.create-upload', assembly, headers=headers, body=body) + :Args: + - template_id (str) - def delete_upload(self, upload_url, headers=None): + Return an instance of """ - Terminate a tus upload + template_id = require_path_id(template_id, "template_id") + return self.request.get(f"/templates/{self._quote_path_segment(template_id)}") - Contract operation: tusd.delete-upload. - Pass protocol headers using headers; binary downloads return bytes. + def list_templates(self, params: Optional[dict] = None): """ - return self.request.tus('tusd.delete-upload', upload_url, headers=headers, body=None) + Get the list of templates. - def download_upload(self, upload_url, headers=None): - """ - Download a tus upload + :Args: + - options (Optional[dict]): + params to send along with the request. Please see + https://transloadit.com/docs/api-docs/#45-retrieve-template-list for available options. - Contract operation: tusd.download-upload. - Pass protocol headers using headers; binary downloads return bytes. + Return an instance of """ - return self.request.tus('tusd.download-upload', upload_url, headers=headers, body=None) + return self.request.get("/templates", params=params) - def get_upload_offset(self, upload_url, headers=None): + def update_template(self, template_id: str, data: dict): """ - Retrieve a tus upload offset + Update the template specified by the 'template_id'. - Contract operation: tusd.get-upload-offset. - Pass protocol headers using headers; binary downloads return bytes. - """ - return self.request.tus('tusd.get-upload-offset', upload_url, headers=headers, body=None) + :Args: + - template_id (str) + - data (dict): key, value pair of fields and their new values. - def tus_options(self, assembly, headers=None): + Return an instance of """ - Discover tus capabilities + template_id = require_path_id(template_id, "template_id") + return self.request.put(f"/templates/{self._quote_path_segment(template_id)}", data=data) - Contract operation: tusd.options. - Pass protocol headers using headers; binary downloads return bytes. + def delete_template(self, template_id: str): """ - return self.request.tus('tusd.options', assembly, headers=headers, body=None) + Delete the template specified by the 'template_id'. - def patch_upload(self, upload_url, headers=None, body=None): - """ - Upload tus file bytes + :Args: + - template_id (str) - Contract operation: tusd.patch-upload. - Pass protocol headers using headers; binary downloads return bytes. + Return an instance of """ - return self.request.tus('tusd.patch-upload', upload_url, headers=headers, body=body) - # - - # High-level upload/resume workflows are maintained by hand. + template_id = require_path_id(template_id, "template_id") + return self.request.delete(f"/templates/{self._quote_path_segment(template_id)}") - def create_tus_assembly(self, file_count: int): - """ - Creates a TUS-ready Assembly that waits for the requested number of resumable uploads before execution continues. + def get_bill(self, month: int, year: int): """ - assembly = self.create_assembly( - data={ - "await": False, - "steps": { - ":original": { - "output_meta": True, - "result": "debug", - "robot": "/upload/handle", - }, - }, - }, - extra_data={ - "num_expected_upload_files": file_count, - }, - ) + Get the bill for the specified month and year. - return assembly + :Args: + - month (int): e.g 1 for January + - year (int) - def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: str): - """Resume from the reported offset, then poll the Assembly to completion.""" - offset_response = self.get_upload_offset(upload_url) - if offset_response.status_code != 200: - raise RuntimeError(f"TUS offset returned HTTP {offset_response.status_code}") - try: - offset = int(offset_response.headers.get("Upload-Offset", "")) - except ValueError: - raise RuntimeError("TUS offset is not an integer.") from None - if not 0 <= offset <= len(content): - raise RuntimeError("TUS offset is outside the supplied content.") - response = self.patch_upload(upload_url, headers={"Upload-Offset": str(offset)}, body=content[offset:]) - if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): - raise RuntimeError("TUS resume did not acknowledge the complete content.") - return self.wait_for_assembly(assembly_ssl_url) - - def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): - """Create an Assembly, upload one file using TUS, and wait for completion.""" - encoded = encode_upload_metadata(fieldname, filename, user_meta) - assembly = self.create_tus_assembly(1) - check_assembly_created(assembly) - created = self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) - if created.status_code != 201: - raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") - response = self.patch_upload(created.upload_url, headers={"Upload-Offset": "0"}, body=content) - if response.status_code != 204 or response.headers.get("Upload-Offset") != str(len(content)): - raise RuntimeError("TUS upload did not acknowledge the complete content.") - completed = self.wait_for_assembly(assembly.data["assembly_ssl_url"]) - return completed, created.upload_url - - def wait_for_assembly(self, assembly_url: str, *, retries=3): + Return an instance of """ - Waits for an Assembly to finish uploading and executing. - Use the returned assembly_ssl_url as the assembly URL. - Retry consecutive rate limits up to retries times, honoring info.retryIn. - """ - if not isinstance(retries, int) or retries < 0: - raise ValueError("retries must be a non-negative integer.") - polling = self.new_assembly() - remaining = retries - while True: - response = self.get_assembly(assembly_url=assembly_url) - data = response.data - - if not isinstance(data, dict): - raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") - - if polling._rate_limit_reached(data): - if remaining == 0: - return response - remaining -= 1 - sleep(polling._retry_delay(data)) - continue - remaining = retries - if data.get("error"): - return response - - # The polling is done if the assembly is not uploading or executing anymore. - if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING", "ASSEMBLY_REPLAYING"): - return response - - sleep(1) - + return self.request.get(f"/bill/{year}-{month:02d}") def new_template(self, name: str, params: Optional[dict] = None) -> template.Template: """ diff --git a/transloadit/endpoint_transport.py b/transloadit/endpoint_transport.py deleted file mode 100644 index 4bafc20..0000000 --- a/transloadit/endpoint_transport.py +++ /dev/null @@ -1,199 +0,0 @@ -"""Shared wire preparation for OAuth, SSE and raw TUS endpoints.""" -import base64 -import asyncio -import copy -import os -from ipaddress import ip_address -import re -from urllib.parse import parse_qs, unquote, urljoin, urlsplit - -from requests.structures import CaseInsensitiveDict -from requests.utils import get_environ_proxies -from aiohttp.helpers import get_env_proxy_for_url -from yarl import URL - -from ._contract import CONTRACT -from .response import Response - - -def sync_network_options(url): - """Honor transport configuration without enabling ambient netrc auth.""" - return {"proxies": get_environ_proxies(url), - "verify": os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("CURL_CA_BUNDLE") or True} - - -async def async_network_options(url, session=None): - # aiohttp exposes the connector publicly, but its session-level proxy defaults - # only through these attributes. Keep explicit proxy/auth ahead of environment. - proxy = getattr(session, "_default_proxy", None) - if proxy is not None: - return {"proxy": proxy, "proxy_auth": getattr(session, "_default_proxy_auth", None)} - if session is not None and not getattr(session, "trust_env", True): - return {"proxy": None} - try: - # Use aiohttp's exact policy (including proxy-only netrc credentials), - # and keep netrc file reads off the event loop like ClientSession does. - proxy, proxy_auth = await asyncio.to_thread(get_env_proxy_for_url, URL(url)) - except LookupError: - return {"proxy": None} - return {"proxy": proxy, "proxy_auth": proxy_auth} - - -def token_request(client, data): - data = copy.deepcopy(data or {}) - if not isinstance(data, dict): - raise ValueError("Token data must be a dictionary.") - selector = CONTRACT["token_auth"] - # Preserve the pre-2.0 draft's omitted-grant default. - grant = data.setdefault(selector["field"], "client_credentials") - try: - authentication = selector["values"][grant] - except (KeyError, TypeError): - raise ValueError("Unsupported token grant_type.") from None - url = client.service.rstrip("/") + "/token" - parsed = urlsplit(url) - try: - loopback = parsed.hostname == "localhost" or ip_address(parsed.hostname or "").is_loopback - except ValueError: - loopback = False - if parsed.username is not None or parsed.password is not None or not ( - parsed.scheme == "https" or (parsed.scheme == "http" and loopback) - ): - raise ValueError("Refusing to send credentials to an insecure bearer token endpoint.") - headers = {"Accept": "application/json", "Content-Type": "application/x-www-form-urlencoded"} - if authentication == "basic": - if not client.auth_secret: - raise ValueError("Bearer token issuance requires an auth secret for this grant.") - credentials = base64.b64encode(f"{client.auth_key}:{client.auth_secret}".encode()).decode("ascii") - headers["Authorization"] = "Basic " + credentials - elif authentication != "none": - raise ValueError("Unsupported contract token authentication.") - return url, data, headers - - -def capability_url(client, url, kind): - """Validate a returned capability URL without signing or following redirects. - - Custom services are explicitly trusted only at their configured origin. - Production capabilities may additionally use the producer's regional hosts. - Persisted upload URLs are accepted so a later process can resume an upload. - """ - validate_raw_url(url) - try: - target, service = urlsplit(url), urlsplit(client.service) - target_port = target.port or (443 if target.scheme == "https" else 80) - service_port = service.port or (443 if service.scheme == "https" else 80) - except ValueError: - raise ValueError("Invalid capability URL.") from None - if target.username is not None or target.password is not None or "#" in url: - raise ValueError("Invalid capability URL.") - same_origin = (target.scheme, target.hostname, target_port) == (service.scheme, service.hostname, service_port) - host_pattern = CONTRACT["capability"]["publicHostPattern"] - production = service.hostname == "api2.transloadit.com" or re.fullmatch(host_pattern, service.hostname or "") - regional = production and target.scheme == "https" and target_port == 443 and re.fullmatch(host_pattern, target.hostname or "") - if target.scheme not in {"http", "https"} or not (same_origin or regional): - raise ValueError("Refusing an untrusted capability destination.") - path = target.path[:-1] if kind == "tus-collection" and target.path.endswith("/") else target.path - valid = matches_capability_path(path, kind) - if kind == "status-stream": - query = parse_qs(target.query, keep_blank_values=True) - ids = query.get(CONTRACT["capability"]["streamQuery"], []) - assembly_route = next(route for route in CONTRACT["capability"]["routes"] if route["kind"] == "assembly") - identity_pattern = assembly_route["parameters"][0]["pattern"] - valid = valid and set(query) == {CONTRACT["capability"]["streamQuery"]} and len(ids) == 1 and bool(re.fullmatch(identity_pattern, ids[0])) - else: - valid = valid and "?" not in url - if not valid: - raise ValueError("Capability URL does not match the requested operation.") - return url - - -def matches_capability_path(path, kind): - for route in CONTRACT["capability"]["routes"]: - if route["kind"] != kind: - continue - parts, template = path.split("/"), route["path"].split("/") - if len(parts) != len(template): - continue - valid = True - for part, expected in zip(parts, template): - if not expected.startswith("{"): - valid = valid and part == expected - continue - field = next(parameter for parameter in route["parameters"] if parameter["name"] == expected[1:-1]) - value = unquote(part) if field["percentDecode"] else part - valid = valid and len(value) >= field.get("minLength", 0) and len(value) <= field.get("maxLength", float("inf")) - if "pattern" in field: - valid = valid and re.fullmatch(field["pattern"], value) is not None - if valid: - return True - return False - - -def validate_raw_url(url): - # Validate before urljoin/urlsplit can erase dot segments or control bytes. - if not isinstance(url, str) or not url or any(c.isspace() or ord(c) < 32 or ord(c) == 127 for c in url) or "\\" in url or re.search(r"%(?![0-9a-fA-F]{2})", url): - raise ValueError("Invalid capability URL.") - path = re.sub(r"^[a-zA-Z][a-zA-Z0-9+.-]*://[^/?#]*", "", url).split("?", 1)[0].split("#", 1)[0] - for part in path.split("/"): - try: - decoded = unquote(part, errors="strict") - except UnicodeError: - raise ValueError("Invalid capability path encoding.") from None - if decoded in {".", ".."} or any(c.isspace() or ord(c) < 32 or ord(c) == 127 or c in "/\\?#" for c in decoded) or re.search(r"%[0-9a-fA-F]{2}", decoded): - raise ValueError("Invalid capability path segment.") - - -def tus_request(client, operation_id, location, headers, body): - spec = CONTRACT["protocols"][operation_id] - supplied = CaseInsensitiveDict(headers or {}) - if any(name.lower() in {"authorization", "proxy-authorization", "cookie", "host"} for name in supplied): - raise ValueError("Account credentials and Host overrides are not TUS headers.") - if any(name.lower() in CONTRACT["capability"]["unsupportedHeaders"] for name in supplied): - raise ValueError("Unsupported TUS header in the API2 contract.") - outgoing = CaseInsensitiveDict(spec["defaults"]) - outgoing.update(supplied) - if spec["destination"] == "tus-collection": - assembly = location.data if isinstance(location, Response) else location - if not isinstance(assembly, dict): - raise ValueError("Pass the Assembly response to a TUS collection operation.") - policy = CONTRACT["capability"] - url = capability_url(client, assembly.get(policy["collectionField"]), "tus-collection") - assembly_url = capability_url(client, assembly.get(policy["assemblyField"]), "assembly") - # A collection and its Assembly can live on different trusted uploaders. - b = urlsplit(assembly_url) - if assembly.get(policy["identityField"]) != b.path.rsplit("/", 1)[1]: - raise ValueError("Assembly URL does not match the Assembly identity.") - if spec["method"] == "POST": - encoded = base64.b64encode(assembly_url.encode()).decode("ascii") - name = policy["metadataName"] - metadata = outgoing.get(policy["metadataHeader"], "") - parts = [part.strip() for part in metadata.split(",") if part.strip()] - # The Assembly capability must come from this validated response. - for part in parts: - if part.split(" ", 1)[0] == name and part != f"{name} {encoded}": - raise ValueError("Upload-Metadata cannot override the Assembly URL.") - parts = [part for part in parts if part.split(" ", 1)[0] != name] - parts.append(f"{name} {encoded}") - outgoing[policy["metadataHeader"]] = ",".join(parts) - if body is not None: - outgoing.setdefault("Content-Type", "application/offset+octet-stream") - else: - url = capability_url(client, location, "tus-upload-resource") - return spec, url, dict(outgoing), body - - -def validate_upload_location(client, url, response): - """Resolve a successful creation's Location and reject foreign destinations.""" - if response.status_code != CONTRACT["capability"]["creationStatus"]: - return response - location = response.headers.get("Location") - if not location: - raise ValueError("TUS creation did not return a Location header.") - validate_raw_url(location) - absolute = capability_url(client, urljoin(url, location), "tus-upload-resource") - # HAProxy can forward creation to a different trusted uploader; its host is - # then returned in Location. Trust policy still rejects arbitrary origins. - # Leave wire headers intact. This convenience value is safe to persist/resume. - response.upload_url = absolute - return response diff --git a/transloadit/network.py b/transloadit/network.py new file mode 100644 index 0000000..f04adc1 --- /dev/null +++ b/transloadit/network.py @@ -0,0 +1,29 @@ +"""Proxy and TLS options for credential-free Assembly status requests.""" +import asyncio +import os + +from aiohttp.helpers import get_env_proxy_for_url +from requests.utils import get_environ_proxies +from yarl import URL + + +def sync_network_options(url): + """Honor transport configuration without enabling ambient netrc auth.""" + return {"proxies": get_environ_proxies(url), + "verify": os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("CURL_CA_BUNDLE") or True} + +async def async_network_options(url, session=None): + # aiohttp exposes the connector publicly, but its session-level proxy defaults + # only through these attributes. Keep explicit proxy/auth ahead of environment. + proxy = getattr(session, "_default_proxy", None) + if proxy is not None: + return {"proxy": proxy, "proxy_auth": getattr(session, "_default_proxy_auth", None)} + if session is not None and not getattr(session, "trust_env", True): + return {"proxy": None} + try: + # Use aiohttp's exact policy (including proxy-only netrc credentials), + # and keep netrc file reads off the event loop like ClientSession does. + proxy, proxy_auth = await asyncio.to_thread(get_env_proxy_for_url, URL(url)) + except LookupError: + return {"proxy": None} + return {"proxy": proxy, "proxy_auth": proxy_auth} diff --git a/transloadit/request.py b/transloadit/request.py index 0f791a1..24806ea 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -2,26 +2,18 @@ import hashlib import hmac import json -from contextlib import contextmanager from datetime import datetime, timedelta, timezone import requests from . import __version__ from .api_url import should_sign_api_url -from .endpoint_transport import capability_url, sync_network_options, token_request, tus_request, validate_upload_location +from .network import sync_network_options from .response import Response, as_response -from .stream import EventParser, StreamError TIMEOUT = 60 -class _ExplicitAuthorization(requests.auth.AuthBase): - """Keep an explicit Authorization header from being replaced by netrc.""" - def __call__(self, request): - return request - - class Request: """ Transloadit tailored HTTP Request object. @@ -39,15 +31,6 @@ class Request: def __init__(self, transloadit): self.transloadit = transloadit - def _headers(self, url): - headers = dict(self.HEADERS) - if getattr(self.transloadit, "bearer_token", None) and should_sign_api_url(url, self.transloadit.service): - headers["Authorization"] = "Bearer " + self.transloadit.bearer_token - return headers - - def _auth(self, url): - return _ExplicitAuthorization() if "Authorization" in self._headers(url) else None - @as_response def get(self, path, params=None): """ @@ -63,8 +46,7 @@ def get(self, path, params=None): return requests.get( url, params=self._to_request_payload(url, params), - headers=self._headers(url), - auth=self._auth(url), + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, ) @@ -94,8 +76,7 @@ def post(self, path, data=None, extra_data=None, files=None): url, data=data, files=files, - headers=self._headers(url), - auth=self._auth(url), + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, ) @@ -119,18 +100,11 @@ def put(self, path, data=None, extra_data=None, files=None): url, data=data, files=files, - headers=self._headers(url), - auth=self._auth(url), + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, ) - @as_response - def patch(self, path, data=None): - url = self._get_full_url(path) - return requests.patch(url, data=self._to_request_payload(url, data), - headers=self._headers(url), auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False) - @as_response def delete(self, path, data=None): """ @@ -147,16 +121,13 @@ def delete(self, path, data=None): return requests.delete( url, data=data, - headers=self._headers(url), - auth=self._auth(url), + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, ) def _to_payload(self, data): data = copy.deepcopy(data or {}) - if getattr(self.transloadit, "bearer_token", None): - return {"params": json.dumps(data)} expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration) if "auth" in data and not isinstance(data["auth"], dict): raise ValueError("auth must be a dictionary when provided.") @@ -188,53 +159,8 @@ def _get_full_url(self, url): def public(self, method, path, params=None, data=None): with requests.Session() as session: - session.trust_env = False # Do not borrow netrc credentials for unsigned endpoints. + session.trust_env = False # Do not borrow netrc credentials for Assembly capability URLs. url = self._get_full_url(path) raw = session.request(method, url, params=params, data=data, headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url)) return Response(raw) - - def issue_bearer_token(self, data=None): - url, data, headers = token_request(self.transloadit, data) - headers.update(self.HEADERS) - with requests.Session() as session: - session.trust_env = False - return Response(session.post(url, data=data, headers=headers, timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url))) - - def tus(self, operation_id, location, headers=None, body=None): - spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) - headers.update(self.HEADERS) - with requests.Session() as session: - session.trust_env = False - raw = session.request(spec["method"], url, data=body, headers=headers, - timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url)) - response = Response(raw, data=raw.content) if spec["binary_response"] else Response(raw) - if spec["method"] == "POST": - validate_upload_location(self.transloadit, url, response) - return response - - @contextmanager - def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): - url = capability_url(self.transloadit, url, "status-stream") - parser = EventParser(max_event_size) - with requests.Session() as session: - session.trust_env = False - with session.get(url, headers={**self.HEADERS, "Accept": "text/event-stream"}, - timeout=(TIMEOUT, read_timeout), stream=True, allow_redirects=False, - **sync_network_options(url)) as response: - if response.status_code != 200: - raise StreamError(response.status_code) - if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": - raise StreamError(response.status_code, "Expected text/event-stream") - - def events(): - # EOF is not Assembly success; callers inspect the final status. - # Keep transport exception types for existing retry policies. - # read1 returns available bytes without waiting to fill a chunk. - while chunk := response.raw.read1(65536, decode_content=True): - for event in parser.feed(chunk): - yield event - if event.terminal: - return - - yield events() diff --git a/transloadit/stream.py b/transloadit/stream.py deleted file mode 100644 index f1017d8..0000000 --- a/transloadit/stream.py +++ /dev/null @@ -1,88 +0,0 @@ -"""Incremental, bounded Server-Sent Event decoding shared by both transports.""" -import codecs -from dataclasses import dataclass -import json - -from ._contract import CONTRACT - - -class StreamError(RuntimeError): - def __init__(self, status_code, message="Assembly stream is unavailable"): - self.status_code = status_code - super().__init__(f"{message} (HTTP {status_code}).") - - -@dataclass(frozen=True) -class AssemblyEvent: - event: str - data: object - id: str = "" - retry: int | None = None - - @property - def terminal(self): - return any(item["name"] == self.event and item["terminal"] for item in CONTRACT["stream_events"]) - - -class EventParser: - def __init__(self, max_event_size=1048576): - if not isinstance(max_event_size, int) or max_event_size < 1: - raise ValueError("max_event_size must be positive.") - self.maximum = max_event_size - self.decoder = codecs.getincrementaldecoder("utf-8-sig")("replace") - self.line = [] - self.data = [] - self.event = "" - self.id = "" - self.retry = None - self.size = 0 - self.after_cr = False - - def feed(self, chunk): - for char in self.decoder.decode(chunk): - if self.after_cr and char == "\n": - self.after_cr = False - continue - self.after_cr = char == "\r" - self.size += len(char.encode("utf-8")) - if self.size > self.maximum: - raise ValueError("Assembly stream event exceeds max_event_size.") - if char in "\r\n": - line = "".join(self.line) - self.line.clear() - if not line: - event = self._dispatch() - self.size = 0 - if event is not None: - yield event - elif not line.startswith(":"): - field, _, value = line.partition(":") - if value.startswith(" "): - value = value[1:] - if field == "data": - self.data.append(value) - elif field == "event": - self.event = value - elif field == "id" and "\x00" not in value: - self.id = value - elif field == "retry" and value.isascii() and value.isdecimal(): - self.retry = int(value) - else: - self.line.append(char) - - def _dispatch(self): - event = None - if self.data: - text = "\n".join(self.data) - kind = self.event or "message" - known_messages = {item["name"] for item in CONTRACT["stream_events"] if item["kind"] == "message"} - if kind == "message" and text in known_messages: - kind = text - try: - data = json.loads(text) - except ValueError: - data = text - event = AssemblyEvent(kind, data, self.id, self.retry) - self.data.clear() - self.event = "" - return event diff --git a/transloadit/upload.py b/transloadit/upload.py index 0f5de29..72f9970 100644 --- a/transloadit/upload.py +++ b/transloadit/upload.py @@ -1,9 +1,7 @@ import asyncio -import base64 import contextvars from functools import partial import os -import re async def run_upload_worker(function, *args): @@ -27,24 +25,6 @@ async def run_upload_worker(function, *args): return future.result() -def encode_upload_metadata(fieldname, filename, user_meta): - metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} - metadata.update({"fieldname": fieldname, "filename": filename}) - for key in metadata: - if not re.fullmatch(r"[!-~]+", key) or "," in key or key == "assembly_url": - raise ValueError("Invalid or reserved TUS metadata key.") - return ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") - for key, value in metadata.items()) - - -def check_assembly_created(response): - if not isinstance(response.data, dict): - raise RuntimeError(f"Assembly creation returned non-JSON data (HTTP {response.status_code}).") - if not 200 <= response.status_code < 300 or response.data.get("error"): - error = response.data.get("error", "UNKNOWN_ERROR") - raise RuntimeError(f"Assembly creation failed: {error} (HTTP {response.status_code}).") - - def get_upload_filename(file_stream, fallback): name = getattr(file_stream, "name", None) if isinstance(name, (bytes, os.PathLike)): From 7164895bb0d1ee6cd2ebcca9618b39fa95e988bb Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 11 Oct 2026 19:54:47 +0200 Subject: [PATCH 63/64] Align async responses and clarify Python 2.0 upgrades --- CHANGELOG.md | 2 +- README.md | 21 +++++++++++++++++++-- docs/source/index.rst | 21 +++++++++++++++++++-- tests/test_assembly.py | 5 ++--- tests/test_async_client.py | 11 +++-------- tests/test_client.py | 5 ----- tests/test_transport.py | 33 +++++++++++++++++++++++++++++++++ transloadit/assembly.py | 4 +++- transloadit/async_assembly.py | 5 ++++- transloadit/async_request.py | 13 +++++++++++-- 10 files changed, 95 insertions(+), 25 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 420a317..579a6ea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,7 @@ ### 2.0.0 / Unreleased ### * Added `AsyncTransloadit` with asyncio support for the existing synchronous client's Assembly, Template and billing methods, plus Smart CDN URL signing. Polling uses `asyncio.sleep`; resumable uploads run tuspy in worker threads. * **Breaking Change**: Python 3.12 or newer is required. Upgrade development, CI and deployment interpreters before installing 2.0. Applications that need Python 3.9–3.11 can pin `pytransloadit<2` (latest 1.x: 1.0.4). -* **Upgrade notes**: Update application constraints for `requests>=2.33,<3` and `urllib3>=2.7,<3`, then regenerate your lockfile. Existing synchronous imports and methods remain available; asyncio applications can use `async with AsyncTransloadit(...)` and await network operations. Keep file context managers open around awaited uploads; cancellation waits for active file reads and resumable upload workers to finish. +* **Upgrade notes**: Update application constraints for `requests>=2.33,<3` and `urllib3>=2.7,<3`, then regenerate your lockfile. Existing synchronous imports and methods remain available; asyncio applications can use `async with AsyncTransloadit(...)` and await network operations. See README for request-handling corrections, including explicit polling retry exhaustion, trusted Assembly URLs, redirect handling and Smart CDN validation/boolean serialization. Keep file context managers open around awaited uploads; cancellation waits for active file reads and resumable workers to finish. Resumable transfers do not inherit an injected aiohttp session's proxy/TLS settings. Source contributors use Poetry 2.4.1 with `[project]` metadata; isolated source builds require `poetry-core>=2.2,<3`. ### 1.0.4 / 2026-05-20 ### * Refreshed locked runtime and development dependencies, including `aiohttp` 3.13.5, `idna` 3.15, `pygments` 2.20.0, Python-version-specific `requests` updates, and `tuspy` 1.1.0. diff --git a/README.md b/README.md index d2b8cf0..4866236 100644 --- a/README.md +++ b/README.md @@ -33,11 +33,23 @@ application pins or constraints and regenerate your lockfile before upgrading: python -m pip install --upgrade 'pytransloadit>=2,<3' ``` -The synchronous client API and imports remain compatible with 1.0.4 on supported -interpreters. SDK 2.0 adds the separate `AsyncTransloadit` client for asyncio +The synchronous imports and methods remain available on supported interpreters. +SDK 2.0 adds the separate `AsyncTransloadit` client for asyncio applications. The dependency refresh shipped in 1.0.4 does not require upgrading to 2.0. +Request-handling changes to account for when upgrading: + +- Smart CDN boolean parameters use `true`/`false` to match the reference CLI. Workspace slugs must be DNS-safe; `auth_key`, `exp` and `sig` are reserved query keys. +- Assembly status/cancellation uses credential-free requests to trusted Assembly URLs. Default Transloadit clients reject foreign destinations; explicitly configured services retain their worker hosts. +- HTTP redirects are returned to the caller instead of followed automatically. Invalid service URLs and empty/dot-segment Template IDs raise `ValueError`. +- Template creation sends steps inside the `template` object. When combining a `template` option with `add_step`, supply an object rather than a serialized JSON string. +- Non-JSON responses return text or bytes in `Response.data`; empty bodies return an empty string. With `wait=True`, exhausting consecutive status rate-limit retries raises `RuntimeError` instead of returning an unfinished Assembly. Normal API error responses still need an `error` check. + +Source contributors use Poetry 2.4.1 with the new `[project]` metadata; isolated +source builds require `poetry-core>=2.2,<3`. Normal pip installation manages the +build backend automatically. + ## Usage ```python @@ -76,6 +88,11 @@ asyncio.run(main()) The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded to worker threads so the event loop stays responsive. +An injected aiohttp session configures Assembly creation and polling. Resumable +file transfers use tuspy's separate Requests transport and do not inherit that +session's explicit proxy or TLS connector settings; configure the Requests +environment for those transfers. + Cancellation of a resumable upload waits for the tuspy upload batch, including retries, to finish before releasing your files. Multipart cancellation waits for any active file read. Timeout and shutdown cleanup can therefore exceed the diff --git a/docs/source/index.rst b/docs/source/index.rst index 9a28ab4..e20eef0 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -63,11 +63,23 @@ application pins or constraints and regenerate your application lockfile. python -m pip install --upgrade 'pytransloadit>=2,<3' -The synchronous client API and imports remain compatible with 1.0.4 on supported -interpreters. SDK 2.0 adds the separate ``AsyncTransloadit`` client for asyncio +The synchronous imports and methods remain available on supported interpreters. +SDK 2.0 adds the separate ``AsyncTransloadit`` client for asyncio applications. The dependency refresh shipped in 1.0.4 does not require upgrading to 2.0. +Request-handling changes to account for when upgrading: + +- Smart CDN boolean parameters use ``true``/``false`` to match the reference CLI. Workspace slugs must be DNS-safe; ``auth_key``, ``exp`` and ``sig`` are reserved query keys. +- Assembly status/cancellation uses credential-free requests to trusted Assembly URLs. Default Transloadit clients reject foreign destinations; explicitly configured services retain their worker hosts. +- HTTP redirects are returned to the caller instead of followed automatically. Invalid service URLs and empty/dot-segment Template IDs raise ``ValueError``. +- Template creation sends steps inside the ``template`` object. When combining a ``template`` option with ``add_step``, supply an object rather than a serialized JSON string. +- Non-JSON responses return text or bytes in ``Response.data``; empty bodies return an empty string. With ``wait=True``, exhausting consecutive status rate-limit retries raises ``RuntimeError`` instead of returning an unfinished Assembly. Normal API error responses still need an ``error`` check. + +Source contributors use Poetry 2.4.1 with the new ``[project]`` metadata; isolated +source builds require ``poetry-core>=2.2,<3``. Normal pip installation manages the +build backend automatically. + Usage ----- @@ -108,6 +120,11 @@ Async usage If you do not use ``async with``, call ``await tl.aclose()`` when you are done with the session. Resumable uploads through tuspy run in a worker thread; polling uses ``asyncio.sleep``. +An injected aiohttp session configures Assembly creation and polling. Resumable +file transfers use tuspy's separate Requests transport and do not inherit that +session's explicit proxy or TLS connector settings; configure the Requests +environment for those transfers. + Cancellation waits for that upload batch, including retries, to finish before releasing caller-owned files. Multipart cancellation drains active file reads. Timeout and shutdown cleanup can therefore exceed the requested deadline; keep diff --git a/tests/test_assembly.py b/tests/test_assembly.py index a65b365..7af956e 100644 --- a/tests/test_assembly.py +++ b/tests/test_assembly.py @@ -331,7 +331,6 @@ def test_save_wait_caps_poll_rate_limit_retries(self): return_value=rate_limited, ) as get_mock: with mock.patch("transloadit.assembly.sleep"): - response = self.assembly.create(wait=True, resumable=False, retries=1) - - self.assertIs(response, rate_limited) + with self.assertRaisesRegex(RuntimeError, "polling exhausted"): + self.assembly.create(wait=True, resumable=False, retries=1) self.assertEqual(get_mock.call_count, 2) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 1151420..e93054e 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -289,7 +289,6 @@ async def asyncTearDown(self): await self.server.close() - async def test_async_client_methods_and_context_manager(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: response = await client.get_assembly(assembly_id="abc123") @@ -462,7 +461,6 @@ async def test_async_client_rejects_invalid_template_ids(self): self.assertEqual(session.calls, []) - async def test_async_client_close_reopens_owned_session(self): client = AsyncTransloadit("key", "secret", service=self.server.base_url) @@ -655,8 +653,6 @@ async def test_async_assembly_wait_raises_on_plain_text_success_poll_response(se sleep_mock.assert_awaited_once_with(0) - - def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self): async_client = AsyncTransloadit("test-key", "test-secret") sync_client = Transloadit("test-key", "test-secret") @@ -1358,7 +1354,7 @@ async def test_async_assembly_wait_does_not_follow_poll_response_assembly_url(se ], ) - async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhausted(self): + async def test_async_assembly_wait_signals_poll_retry_exhaustion(self): async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client: assembly = client.new_assembly() @@ -1389,9 +1385,8 @@ async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhaus new=mock.AsyncMock(return_value=rate_limited), ) as get_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: - response = await assembly.create(wait=True, resumable=False, retries=1) - - self.assertEqual(response.data["error"], "RATE_LIMIT_REACHED") + with self.assertRaisesRegex(RuntimeError, "polling exhausted"): + await assembly.create(wait=True, resumable=False, retries=1) post_mock.assert_awaited_once() self.assertEqual( get_mock.await_args_list, diff --git a/tests/test_client.py b/tests/test_client.py index b2f2f47..7b3cec5 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -92,10 +92,6 @@ def test_assembly_urls_are_trusted_and_unauthenticated(self): ) - - - - def test_quotes_path_ids(self): with mock.patch.object(self.transloadit, '_request_assembly_url') as assembly_mock: with mock.patch.object(self.transloadit.request, 'get') as get_mock: @@ -129,7 +125,6 @@ def test_rejects_invalid_template_ids(self): self.transloadit.delete_template(template_id) - @requests_mock.Mocker() def test_list_assemblies(self, mock): url = f"{self.transloadit.service}/assemblies" diff --git a/tests/test_transport.py b/tests/test_transport.py index cc047c8..cdd4589 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -35,11 +35,18 @@ async def handle(self, request): fields = {key: values[0] for key, values in parse_qs(data.decode()).items()} self.requests.append({"method": request.method, "path": request.path, "body": data, "filenames": filenames, "fields": fields, "query": dict(request.query), + "query_items": list(request.query.items()), "headers": CaseInsensitiveDict(request.headers)}) if request.method == "GET" and request.path == "/assemblies/" + ASSEMBLY_ID: return web.json_response({"ok": "ASSEMBLY_COMPLETED", "assembly_id": ASSEMBLY_ID}) if request.method == "POST" and request.path == "/assemblies" and hasattr(self, "assembly_response"): return web.json_response(self.assembly_response) + if request.path == "/templates/empty": + return web.Response(status=204) + if request.path == "/templates/whitespace": + return web.Response(text=" \n") + if request.path == "/templates/json-null": + return web.json_response(None) return web.json_response({"ok": "OK"}) @@ -302,3 +309,29 @@ async def call(client, method, *args, **kwargs): if isinstance(client, AsyncTransloadit): return await operation(*args, **kwargs) return await asyncio.to_thread(operation, *args, **kwargs) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("template_id,expected", [("empty", ""), ("whitespace", " \n"), ("json-null", None)]) +def test_delete_template_preserves_empty_body_and_json_null(mode, template_id, expected): + async def scenario(): + async with wire_client(mode) as (client, server): + response = await call(client, "delete_template", template_id) + assert response.data == expected + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_unsigned_get_encodes_booleans_omits_none_and_repeats_lists(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + client.service = "https://api2.transloadit.com" + params = {"enabled": True, "unused": None, "ids": [1, None, 2]} + if mode == "async": + response = await client.request.get(server.url + "/unsigned", params=params) + else: + response = await asyncio.to_thread(client.request.get, server.url + "/unsigned", params=params) + assert response.status_code == 200 + assert server.requests[-1]["query_items"] == [("enabled", "True"), ("ids", "1"), ("ids", "2")] + assert "signature" not in server.requests[-1]["query"] + asyncio.run(scenario()) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 5dbfdad..47e0571 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -113,6 +113,7 @@ def create(self, wait=False, resumable=True, retries=3): - retries (Optional[int]): In the event of an upload failure, this specifies how many more times the upload should be retried before crying for help. This option is only available if 'resumable' is set to 'True'. Defaults to 3 if not specified. + Also caps consecutive status rate limits when wait=True; exhaustion raises RuntimeError. """ data = self.get_options() file_positions, missing_file_positions = self._snapshot_file_positions() @@ -173,7 +174,8 @@ def create(self, wait=False, resumable=True, retries=3): while not self._assembly_finished(poll_data): if self._rate_limit_reached(poll_data): if remaining_rate_limit_retries <= 0: - return poll_response + # Bounded retries must not return an unfinished Assembly as wait=True success. + raise RuntimeError("Assembly status polling exhausted the rate-limit retry budget.") remaining_rate_limit_retries -= 1 else: remaining_rate_limit_retries = poll_retries diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index c3c12db..f7b676c 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -89,6 +89,8 @@ async def create(self, wait=False, resumable=True, retries=3): """ Save/Submit the assembly for processing. + With wait=True, exhausted consecutive status rate-limit retries raise RuntimeError. + Resumable uploads use a tuspy worker thread. Cancellation waits for that upload batch, including retries, to finish before releasing caller-owned files. Consequently, cancellation and timeout cleanup may take longer than @@ -153,7 +155,8 @@ async def create(self, wait=False, resumable=True, retries=3): while not self._assembly_finished(poll_data): if self._rate_limit_reached(poll_data): if remaining_rate_limit_retries <= 0: - return poll_response + # Bounded retries must not return an unfinished Assembly as wait=True success. + raise RuntimeError("Assembly status polling exhausted the rate-limit retry budget.") remaining_rate_limit_retries -= 1 else: remaining_rate_limit_retries = poll_retries diff --git a/transloadit/async_request.py b/transloadit/async_request.py index bf2a977..5408bf4 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -175,7 +175,13 @@ def _normalize_payload(self, data): async def _read_response_data(self, response): try: - return await response.json(content_type=None) + data = await response.json(content_type=None) + if data is None: + # aiohttp maps empty/whitespace bodies to None; Requests returns their text. + text = await response.text() + if not text.strip(): + return text + return data except (aiohttp.ContentTypeError, json.JSONDecodeError, UnicodeDecodeError): try: return await response.text() @@ -187,9 +193,12 @@ async def get(self, path, params=None): Makes an asynchronous HTTP GET request. """ url = self._get_full_url(path) + query = self._to_request_payload(url, params) + if not should_sign_api_url(url, self.transloadit.service): + query = self._normalize_payload(query or {}) async with self._api_session(url) as session, session.get( url, - params=self._to_request_payload(url, params), + params=query, **(await self._request_options(url)), ) as response: return Response( From 3c0a3a3618c952ae6b68096ce0ccd3421714b11f Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 11 Oct 2026 20:06:49 +0200 Subject: [PATCH 64/64] Preserve polling recovery details and query encoding --- README.md | 2 +- docs/source/index.rst | 2 +- tests/test_assembly.py | 6 +++++- tests/test_async_client.py | 6 +++++- tests/test_response.py | 29 ++++++++++++++++++++++++++++- tests/test_transport.py | 13 ++++++++++--- transloadit/assembly.py | 5 +++-- transloadit/async_assembly.py | 5 +++-- transloadit/async_request.py | 6 +++++- transloadit/response.py | 28 +++++++++++++++++++++++++++- 10 files changed, 88 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 4866236..c36630d 100644 --- a/README.md +++ b/README.md @@ -44,7 +44,7 @@ Request-handling changes to account for when upgrading: - Assembly status/cancellation uses credential-free requests to trusted Assembly URLs. Default Transloadit clients reject foreign destinations; explicitly configured services retain their worker hosts. - HTTP redirects are returned to the caller instead of followed automatically. Invalid service URLs and empty/dot-segment Template IDs raise `ValueError`. - Template creation sends steps inside the `template` object. When combining a `template` option with `add_step`, supply an object rather than a serialized JSON string. -- Non-JSON responses return text or bytes in `Response.data`; empty bodies return an empty string. With `wait=True`, exhausting consecutive status rate-limit retries raises `RuntimeError` instead of returning an unfinished Assembly. Normal API error responses still need an `error` check. +- Non-JSON responses return text or bytes in `Response.data`; empty bodies return an empty string. With `wait=True`, exhausting consecutive status rate-limit retries raises `AssemblyPollingError` (a `RuntimeError` subclass). The Assembly may still be running: use the error's `assembly_url` to resume polling or cancel, and inspect `assembly_response`/`last_response` for creation and rate-limit details. Normal API error responses still need an `error` check. Source contributors use Poetry 2.4.1 with the new `[project]` metadata; isolated source builds require `poetry-core>=2.2,<3`. Normal pip installation manages the diff --git a/docs/source/index.rst b/docs/source/index.rst index e20eef0..886d72f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -74,7 +74,7 @@ Request-handling changes to account for when upgrading: - Assembly status/cancellation uses credential-free requests to trusted Assembly URLs. Default Transloadit clients reject foreign destinations; explicitly configured services retain their worker hosts. - HTTP redirects are returned to the caller instead of followed automatically. Invalid service URLs and empty/dot-segment Template IDs raise ``ValueError``. - Template creation sends steps inside the ``template`` object. When combining a ``template`` option with ``add_step``, supply an object rather than a serialized JSON string. -- Non-JSON responses return text or bytes in ``Response.data``; empty bodies return an empty string. With ``wait=True``, exhausting consecutive status rate-limit retries raises ``RuntimeError`` instead of returning an unfinished Assembly. Normal API error responses still need an ``error`` check. +- Non-JSON responses return text or bytes in ``Response.data``; empty bodies return an empty string. With ``wait=True``, exhausting consecutive status rate-limit retries raises ``AssemblyPollingError`` (a ``RuntimeError`` subclass). The Assembly may still be running: use the error's ``assembly_url`` to resume polling or cancel, and inspect ``assembly_response``/``last_response`` for creation and rate-limit details. Normal API error responses still need an ``error`` check. Source contributors use Poetry 2.4.1 with the new ``[project]`` metadata; isolated source builds require ``poetry-core>=2.2,<3``. Normal pip installation manages the diff --git a/tests/test_assembly.py b/tests/test_assembly.py index 7af956e..ca65cc1 100644 --- a/tests/test_assembly.py +++ b/tests/test_assembly.py @@ -331,6 +331,10 @@ def test_save_wait_caps_poll_rate_limit_retries(self): return_value=rate_limited, ) as get_mock: with mock.patch("transloadit.assembly.sleep"): - with self.assertRaisesRegex(RuntimeError, "polling exhausted"): + with self.assertRaisesRegex(RuntimeError, "polling exhausted") as caught: self.assembly.create(wait=True, resumable=False, retries=1) + self.assertEqual(caught.exception.assembly_url, initial_response.data["assembly_ssl_url"]) + self.assertIs(caught.exception.assembly_response, initial_response) + self.assertIs(caught.exception.last_response, rate_limited) + self.assertIn(initial_response.data["assembly_ssl_url"], str(caught.exception)) self.assertEqual(get_mock.call_count, 2) diff --git a/tests/test_async_client.py b/tests/test_async_client.py index e93054e..b7fe446 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -1385,8 +1385,12 @@ async def test_async_assembly_wait_signals_poll_retry_exhaustion(self): new=mock.AsyncMock(return_value=rate_limited), ) as get_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock) as sleep_mock: - with self.assertRaisesRegex(RuntimeError, "polling exhausted"): + with self.assertRaisesRegex(RuntimeError, "polling exhausted") as caught: await assembly.create(wait=True, resumable=False, retries=1) + self.assertEqual(caught.exception.assembly_url, initial.data["assembly_ssl_url"]) + self.assertIs(caught.exception.assembly_response, initial) + self.assertIs(caught.exception.last_response, rate_limited) + self.assertIn(initial.data["assembly_ssl_url"], str(caught.exception)) post_mock.assert_awaited_once() self.assertEqual( get_mock.await_args_list, diff --git a/tests/test_response.py b/tests/test_response.py index b58a13c..3d5f8e9 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -1,7 +1,10 @@ +import pickle import unittest from unittest import mock -from transloadit.response import Response, _MISSING +import requests + +from transloadit.response import AssemblyPollingError, Response, _MISSING class ResponseTest(unittest.TestCase): @@ -74,3 +77,27 @@ def test_response_supports_async_preloaded_values_and_empty_default(self): self.assertEqual(response.data, {"ok": "async"}) self.assertEqual(response.status_code, 202) self.assertEqual(response.headers, {"X-Test": "1"}) + + + def test_sync_response_keeps_values_after_pickle(self): + raw = requests.Response() + raw.status_code = 429 + raw._content = b'{"error":"RATE_LIMIT_REACHED"}' + raw.headers = {"Retry-After": "1"} + recovered = pickle.loads(pickle.dumps(Response(raw))) + self.assertEqual(recovered.data, {"error": "RATE_LIMIT_REACHED"}) + self.assertEqual(recovered.status_code, 429) + self.assertEqual(recovered.headers["Retry-After"], "1") + + def test_polling_error_keeps_recovery_details_after_pickle(self): + url = "https://api2-region.transloadit.com/assemblies/test" + created = Response(data={"assembly_id": "test"}, status_code=200, headers={}) + last = Response(data={"error": "RATE_LIMIT_REACHED"}, status_code=429, headers={}) + original = AssemblyPollingError(url, created, last) + recovered = pickle.loads(pickle.dumps(original)) + self.assertIsInstance(recovered, RuntimeError) + self.assertEqual(recovered.assembly_url, url) + self.assertEqual(recovered.assembly_response.data, created.data) + self.assertEqual(recovered.last_response.data, last.data) + self.assertEqual(recovered.last_response.status_code, 429) + self.assertEqual(str(recovered), str(original)) diff --git a/tests/test_transport.py b/tests/test_transport.py index cdd4589..e02a02b 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -322,16 +322,23 @@ async def scenario(): @pytest.mark.parametrize("mode", ["sync", "async"]) -def test_unsigned_get_encodes_booleans_omits_none_and_repeats_lists(mode): +@pytest.mark.parametrize("params,expected", [ + ({"enabled": True, "unused": None, "ids": [1, None, 2]}, [("enabled", "True"), ("ids", "1"), ("ids", "2")]), + ([("a", "1"), ("a", "2")], [("a", "1"), ("a", "2")]), + ("a=x%2Fy&b=two+words", [("a", "x/y"), ("b", "two words")]), + ({"b": b"x"}, [("b", "x")]), + ({"s": {1, 2}}, [("s", "1"), ("s", "2")]), + ({"nested": {"key": "value"}}, [("nested", "key")]), +]) +def test_unsigned_get_preserves_requests_parameter_encoding(mode, params, expected): async def scenario(): async with wire_client(mode) as (client, server): client.service = "https://api2.transloadit.com" - params = {"enabled": True, "unused": None, "ids": [1, None, 2]} if mode == "async": response = await client.request.get(server.url + "/unsigned", params=params) else: response = await asyncio.to_thread(client.request.get, server.url + "/unsigned", params=params) assert response.status_code == 200 - assert server.requests[-1]["query_items"] == [("enabled", "True"), ("ids", "1"), ("ids", "2")] + assert server.requests[-1]["query_items"] == expected assert "signature" not in server.requests[-1]["query"] asyncio.run(scenario()) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 47e0571..1de7dd5 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -4,6 +4,7 @@ from tusclient import client as tus from . import optionbuilder +from .response import AssemblyPollingError from .upload import get_upload_filename @@ -113,7 +114,7 @@ def create(self, wait=False, resumable=True, retries=3): - retries (Optional[int]): In the event of an upload failure, this specifies how many more times the upload should be retried before crying for help. This option is only available if 'resumable' is set to 'True'. Defaults to 3 if not specified. - Also caps consecutive status rate limits when wait=True; exhaustion raises RuntimeError. + Also caps consecutive status rate limits when wait=True; exhaustion raises AssemblyPollingError with recovery details. """ data = self.get_options() file_positions, missing_file_positions = self._snapshot_file_positions() @@ -175,7 +176,7 @@ def create(self, wait=False, resumable=True, retries=3): if self._rate_limit_reached(poll_data): if remaining_rate_limit_retries <= 0: # Bounded retries must not return an unfinished Assembly as wait=True success. - raise RuntimeError("Assembly status polling exhausted the rate-limit retry budget.") + raise AssemblyPollingError(assembly_url, response, poll_response) remaining_rate_limit_retries -= 1 else: remaining_rate_limit_retries = poll_retries diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index f7b676c..8f5b728 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -4,6 +4,7 @@ from tusclient import client as tus from . import optionbuilder +from .response import AssemblyPollingError from .upload import get_upload_filename, run_upload_worker @@ -89,7 +90,7 @@ async def create(self, wait=False, resumable=True, retries=3): """ Save/Submit the assembly for processing. - With wait=True, exhausted consecutive status rate-limit retries raise RuntimeError. + With wait=True, exhausted consecutive status rate-limit retries raise AssemblyPollingError with recovery details. Resumable uploads use a tuspy worker thread. Cancellation waits for that upload batch, including retries, to finish before releasing caller-owned @@ -156,7 +157,7 @@ async def create(self, wait=False, resumable=True, retries=3): if self._rate_limit_reached(poll_data): if remaining_rate_limit_retries <= 0: # Bounded retries must not return an unfinished Assembly as wait=True success. - raise RuntimeError("Assembly status polling exhausted the rate-limit retry budget.") + raise AssemblyPollingError(assembly_url, response, poll_response) remaining_rate_limit_retries -= 1 else: remaining_rate_limit_retries = poll_retries diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 5408bf4..f9204f3 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -12,6 +12,7 @@ from types import MappingProxyType import aiohttp +import requests from requests.structures import CaseInsensitiveDict from . import __version__ @@ -195,7 +196,10 @@ async def get(self, path, params=None): url = self._get_full_url(path) query = self._to_request_payload(url, params) if not should_sign_api_url(url, self.transloadit.service): - query = self._normalize_payload(query or {}) + # Preparing a URL performs no I/O and preserves Requests' query semantics + # for mappings, repeated pairs, strings, bytes and iterable values. + url = requests.Request("GET", url, params=query).prepare().url + query = None async with self._api_session(url) as session, session.get( url, params=query, diff --git a/transloadit/response.py b/transloadit/response.py index 33d25d3..ff3aac8 100644 --- a/transloadit/response.py +++ b/transloadit/response.py @@ -1,7 +1,13 @@ +from enum import Enum from functools import wraps -_MISSING = object() +class _Missing(Enum): + # Preserve sentinel identity when responses cross process/serialization boundaries. + VALUE = 0 + + +_MISSING = _Missing.VALUE class Response: @@ -79,6 +85,26 @@ def headers(self): return self._response.headers +class AssemblyPollingError(RuntimeError): + """Polling stopped after repeated rate limits; the Assembly may still be running. + + ``assembly_url`` can be passed to get_assembly or cancel_assembly. + ``assembly_response`` contains the initial creation response, and + ``last_response`` contains the final rate-limit response. + """ + + def __init__(self, assembly_url, assembly_response, last_response): + super().__init__( + f"Assembly status polling exhausted the rate-limit retry budget: {assembly_url}" + ) + self.assembly_url = assembly_url + self.assembly_response = assembly_response + self.last_response = last_response + + def __reduce__(self): + return type(self), (self.assembly_url, self.assembly_response, self.last_response) + + def as_response(func): """ Decorator function that converts the output of a function into an instance

bl&c$x8kXG}2g}hKc%8PEAoutwy%%c~~kdnw;RKCywV_*ZChD8$IRUZn`C7KOqJR&|!{Ujs6`0i25~2c`02b>CdzOyG&H?zMtFXzec21Ly z)G`xGO%!>AYBLyEIB?&k^ebwK$toCeYZlN9i#SQQ3D3)G~=pLGv_gT`O1JAZA67&BV2WkwH|o7zIHwc(!?lwaeQ^ z3u(!i>fyL5J_+KGLQPF>T<1GXJMOYUF!AZJ!k`O6iT@qsUSYw?U`(DP6FUXgNy3X> zfFdHSwO0&unP=)b1tL~OrpZ0*KJ2*AECzasHp9q~rjY_O03}cz%BkC$u~xJql&r{P zH-H8VCP-V$dTVMw!NV)S6NnSXWePQe`m~s3WL@E+jA9MND6?|c8>O=oUhE(;m=Dae=Fv;ce_5HtV76#M zmWhohZl>&Pf=d}Xk?ukvOuGeE0`jtkytbkbu<9o3aO_h&A9yDoq-K6HPv=!yc4&ju z1UUjh=Z=J2qW0ilX@I)8TGnVSI+U5_fC^ZNYfy9yw}n2G^5rwlLZdu|X7S5i6HsgY zGtUg*tc7q?3ZPAK=%cXX>%!V_oAOZOVtLrM5Qu&G`qpRBETWTlr~sLXB?7V1M`(r?~jO$g)1}x6#*e?>&1r^bnF_?3Z{=-2cApN zbgjx}E|Mm}cdH2Bks8v?WsV&N-h2b|O*&R7@h&0iSPZC2iMVRQ4;tEPQWxJA_%%4p3G@d7GF)Ub=kyzrIF7HZ3tH?Fdl15%b05J-N0n%N?pqCcifPmoi z*|JWd@D^qYG>^a+^cPwfuuWR(PPA596a~VOVkc7tep}H{Q#%l?Kw>oUkUOstqhCe} z>{?k!x&&L-@DMa169j1zU#oXmb-vKlRF$BA5GR$?388z+5tVpBxjABEQq$=a|KUBgr7I(vy@MEvBhAAU+874|ojd=}J z@`li7x4;ayRr3Oxdc^+FbCt^(8h8@!a+?-qjuowNO??NAC{w4|wx&%XKc*R}VFoiQ zBEM94g2d6Zxt2p3_*07EGj(2K4}lyU+X6Oh6Q5zv+Cnixy9MSL;atnvCK$S$#==b< zEF?)Qm}>}HkiitUcz6}wSz!dTU0cM6@i0;#kczN^?1;3~0=o|o=BDj%@CynDH?)tT zs}jK2gW#?55T5Ul<{tX_!XE^Q!64g zm&J5=iQZ|7M#P9NErTKlExsB0~V?gmsbfjf>Zwl+1U*EeO1JIqY(gm*P?Py%B}B34nWG?i>j;$u4_ zHPp6_z~8$CwwhJI`6--SXQLe+X@xn($U_Yad3aW#9`FuL8H3|aaSl-P#5N;Q1bhzQ zM_RK~%hR@f``h=Uv1Alz_Gt0?(q*I!mp6Q;Zib*nkrj^>%T zT8gLVAsjFqe$N%ah1Xmt7y-#qES?@7Sq?^?gKukv@PT%qYNt^|WZdjNK$|Km zwABJ*n;~7L;>v=7@!&~hn$rUV@+wBoXqg4cwoTP(Zx}x72x&(pJIr3yDp0m{&^}Ev z6q#lPAV{#$IHNDXMEX+dXbofzh0bACBdSL?+1yDTuqjA|_SxX86q+EmPMb0^;JT{- zGDRVJ*hyys6t+`jz{u3SrtWI|tg5uW3>ZMzsv_kP<4Oz6+F65sWUUAIVO3BD1R;wH zEck`HMvA7wO0y1&QslU>7(70Z6-aF@H(SdyB}FJ`6|XEcd^e$wHA^7Qyjx(^C~%r~ zR$AqDz-)o6!3%4fS1^VKOqAezXicY0g%T!EN7HY~$o`ZzG7HTTC{WRW$ku7YN(IJ> zMU)woFtZ9A3Qd_7O`~-PDxP9wnr4@9wrvUY6`(%fuB!y4#?s^EQ379(8((4Wai4R< zsnTjb)V9SoBAeOBR26i&X7sectgTdymaH}PZ8Q-U_qzm5RwAi%g)M9aTg$Zi0X&HZ zjuhA`U_w_)DQxQ!6YI z-?a52o&_q|Q2m_CTD!%8sr^WSrQo>iFao9nslWg4x16;NWafL72Os(>W4BOW~lH*=az&$V`%(fyf1M721Pfndn8(LTLIJ2*0@umBit z3WWti8M81_U}ZayADI)&)#{KY8o);Ah9=h=O+)8(VP#odX`znR@~Ad50GvAont~Ve z1a_4A3_WW#GjG6Eg#+b5Q9{1dhSEeMg(#vO36hgFNMSlM-AA9dNuiKYY-X3FnK*UB z@HSOZX822mCZWAT6H4uD3)(L0t?W&~wOu^KE2-7K3rOkd5i9Q@EO08E{(6KG8^zaHT@Y87{xHn@|uX0a;ifa0yK z&694VKww6pI+$EIHYU?3UaHd;7p==-i?k-6F%+^PP%n8YjnlpwZ5h}t5Wv=oycN=F zb0TyOdG;dbUb@jp~W9egUwEI64ndZC8g0U0>!VWdDb zB?G6noM3w4_Ui0jrPC*YXoU9|8W{31#bBvE5v`N?PSux!Y>P_{@)Vr`+xIyxR^kcV~EE2~LIARyESxuiN+MJi? z3|fPy0v2>>4E?|WVb)~Lb_-PU4J1x(lA)v0O7Y`$t7!`Cp)^+W?~GCB@bvg%9WwAi zdV`%DsUgH1J*ERa)uf0j1Q|+LM5S1VOd*sRl%d5u))xQDg`joQ2EPCge78VtY)p~9 z23gaNDDiW}9d$T3I7OOu$MHsU66Gl2gCZzp?v?r^AK7@-X{&hNXtRvycoP~;h87rS z4768BpJx!dR&kO^23y8JDcgXhk1IQ}Z?rR_F3@&OHEZ57)Bb#_5VYAR(e8V|vD6Ht zY@JO?oC{=Jai%Dy9Vrlv!j%sS^bYzmP6{HPDa<){XoqGaT!Tl1l4|!cWz{m2n96!2 z<3tB|We^Rm?THOlT0t^tjexkUqbsmiWpv>ikjygF4whZD&gGg#9_d50yl!HwjkG|q zEp?eH(#8Zq1pFpgCA?8LKveJ%kZFc2S2WznmhBEu##hO;t5b_6_=H7)93kH_nQ5p) zn~I_#?{OJB3J*pNf{eK5BL%jhqYi)$KKN;Tb8gDfQi|XcWdlnMtW2FBHy;!U2WAVcfF_ zj|CiTP|kzUDhWhBBG?wXk|-n$Vg&c7Os&a*5XmR5ONc2(8YLl8z6A)oViRB~33^S< zlaT_!(^`?!Ikvghu2gynX4o2e#Hr>TJpK!|-^oKNML0Xfu_}0W#0$WP0ti3^`c~l_ zQ(1bi>kNpeUDrxnq2vex#s=3M;{Y8;U0`B3TX_O{+zBX(=QezfqGK>4;6SHC1ql zR)GuL*-8nn8cmFZ79)ejtFTdp$Tgmmq8#d6tHhvAmVhQBeW)ZZT}TRFhLGc;0JcUE zp(*|&!p2KE&RG?-pp-Y61h!O6YtX#p$SkonwM-I@pw$|)#f&y>reMPa9}LWZ_u^Wm zaoHMn)Jh5(4{g?N$zo(swAcy8YAdy92I`uMVq>e7N(Q)6jLAX~7?r$|-Xb^(qV7q*@TE zJKy4KbS>&NGJgo{%7;>BstzDT8ljvtD5(H3I@Vf;LnOPaLcGV(w_24+O|aUuQTe9W73`>) z+FFDuC`!5ih+3-%KLu^Mk}rU{+7JLr+C-ZHEbnMKtOGlC{S^`l(uyy-^5_#O5dKvlW~Wl6xP0Ua`6RMCK%9#+B=@E)f!FDpzzM<>*# zXch3Crz2ux3fw)qDk(FZPw?L(LY<~@vA=+7Og*ESrzTOuwYiHA!6yZL+ED`$(q_KrUPL+7kC`c5m0>(HC^F{J7tts5bLl{FIN=4^@ z@gs5=wCn*ibdAC#Xsv?mfpAEZ)8wmOi<^=JX`qr4qm*%bPjGyBr$CRkYr9_ADK#ac z3RWmTj$(fxgg8!$M#mY1(SbrZpjsq`JXE5R#*Gz-P#6WKFx+$%=#_$l89qQuUm}tn z!h?$>SaYX>2%8-*+(&oWG*}Y$cxlSdS!NDk@vrxNTu|eGnWf}kt^}kjbL`qH3 zV8)eQ3fY1El*$y4C7=<$K&AvWjAYieBQx#3#96?@Rgh-Yc+6%|Xb&VzkpF8YO#ySr zWU2_nM7yAs)XH1n200oj5Q~WM@wCQgkVQx_j;YcYmL=wo_A9I+F^XqOTCGxJla=xy z`rpki$3~SEEQeufYb9}kb2EfVkve>b0+kJ!7CPz(8k$~3Q?uM_UOG{P>TZEe0bvhX z`*2EWs8kjimDGke$VaY>O<1i`i0+lF6Q-TYgjGfKYeow6p0TxQ={30vZh@wu&=d;# z3RG+MLh}cW7IBrZ57tLhdj5qFtz_HI?u7bS{aBzl8q9Y;&B+) zRM;9UVCS{(wJeo%F&WWiXlbV<5R8dWi@>*e6c66fci1gpweGA7c)IXekCUP0l{(WN zy9ys@q`)A@gyE~DfcRxyQ3i$}`SL|PO;iw}@;p@9Y~~eCouwgf8xIxrBfBy^3a|W68Hf!$gHu@at}=;M zG^-*&J4}P3Ljk!&*RD{Y z8!n;fk&$?tpw-h(GsGfO{J+!I*1{S3$lw*>l41o!W|h1SQe7+du<%+JF2l&&SEv)^ zU(~(|<6~k1rKqC1xKYZz1S5k?<0fF6vP#<(U`REhh2X*=NBXeVx@iuR3D{4x4$7J- ztBR=|f~w0_v)71&7K&<&6d;wx9TC7;zzfAj zA*nQ1DX{7Ucu$;Sdx{aV6trSeD#@Lpsi0Sd7(tI}A9tUE86FE<*?vB;(cG_sF|hIw z+pZWZ5MJMiv{xb#Vlbi5re392z)Mu}2q=2c-h8Ebz%zv?D@~Rr5=H{NgJyygr7$Wg zg~OC}*)-UZJXAhW1ZtcIf*A${f#oqVxYolI)vL(#kpe?oYNDvY5rG+-j0VD4w9*C= zz~FqNAg@fZ{AGf)py=9Ysx;8~$VLM+Kw-a?4XLtY%KNfV*|gT4A>Ib_g4S>7I9~*- zo!o7!nD^Q#-P(xQC~{1*H0Ui9rje{9wZh*pmD*KqY>{?Oj*9L0qt%Y9Cg#M++p(Ps zLA$8B60RpOY?MLRY8||Dz%0$j#-KDXue$5NOYIfIhtfJl>yfQ`q(I-Pg|#+{i$f@- zR$~$R04v&u8FU;; zoP1^X#)Z_LQL#zo_o;&!DNrgFl(Ha8YpibGfL$hwv6{wePY7KPcG)sB2)8quk!(F~ zkd}}_pM(F&R#yGL_fzNR%Ibf0T7ZGd;<#S{vR*>V)=LGtB?G}@)?C> z8}}9$v+2Tb-rPDXKnEE7#`Cr5>4#?%v+$e8OB_>y?4g_4%X2?nJ~WGkKkv?7o-CGT zdAT@Q75=cBxtCii`xtUK)cSaS~ zk3D(s+Nl!Pt8}@1rgIalQJ0QX1l^eX`N?wjrJpWN?Ae5;H&0u*Ua76;w@+@km@St5 zjg9(UJ#p;6GUpdGNoV<-FrX)H65`k`PtMHr^wOOAozJQMC&P=|U)ye(PR2O%YI6K@ zF5V%$)+q_FMlZD+eb_npBo^0Qo_z_9o_Pe^ne!7B ze_zF(&z|3Fp^UKgXD6#3c>VI`UV44+50tuK%%;rs?p|icXF+bXL|x78`m4Ry|~22L&5yxR(Wm)QQ73qlc_zs zben^5@?t`HlcmHmO7&I&uWr$|UN*}U2tW7SEIuhYq7MCAh}y~2GlVp%^IX15R#!4T zBBhga1m#NTH!2ZNX&k*{F5P6dx1!KDmshmm@wS}Dex`flF_+hL;M`2n{IeN7OfURl z)*%FN=F!LcyGYdJo*+{uNXN4IHe{q|U( zRKpwSg#GdaHHm5#8+Ic7h#zB!=l*nqCf?K`QK`=+=aVHeJJv6gQ{*%X)znhx`tdsp z9wllUCC|Pb7}$e5$lKi?x;&R_bn3Ms_gB#H_(M9JA)0TOr6;1-bfXox zx%B%ZIx6i=u$;|uU%Rl$VsW{R|F?JTb^A76>e*zmmY#`!eSc%Kyq8;2eqUt|9I2nT zx#vRfsknRe-(qef(J9%W+h=@4{cZyoK1_705*L{rZJYCl?o9 zENCe`pxKh(+1$)uo?KkcAv25FYY`^R&;)H z%~!sql?y+IkkA`&SpS@#Tc3o@F0T8IyHBmWKzQ#T%yZMPLcF>XU0%3*oiG~8dlTmW zTG6jl9>e2SlO{d0ef`pAFQ$s*$6dM;a)?oc872SGba9ci& znyEFjBpq%|qIfPxzOr7Iocpb>ZPfPS z67pz&gQxw8S;FAevB&>GI&kvyU;K-&rY9%wKQ<@-l$^9re*TLOhF?#f{4se@R$s5~ zy#I^OKYzF}f5KmOcK)-~H|Dd;<<=U(#%jW|*of=L(jS{M)rDq1-&tHZTAf(Fy{fQv zc>M8~lj-W{_RTr(ZRlG*o5hDd`Q4|VZ8^yoz6b7)`#~C+Jl}j=^9~f&x8m`Wtvhki z^!U*gOFzE8{PMbevGv#X@%6*|)79|fsBOXamikNpPo7%NFa5|9&&}E8$k#UxvVRoK z#z}9Vj(47Va_!33@7;9w_5mH{hKJ9L4(DJ0>dw&|x1u)>>U%eJ@VayR5o-#EGe12=s7LCw2`{)G$v;0%0hq|3@Icb~Yh7rD3u*K9KezmvuKwnBn{8gG zbU|0L)s-?{$u}<*{Uu$iR@d_3TD@6Xwz`-lo9`!AmsLhNTyHlnS6r%x>&@o%hHJ%e zqu#nvaxow7RNHrojhdF%Zq*z2itG34jj!c9H_MGmX1jNrBo;k#y?*~^d#KIpi_OSl z^|)R7{PVA}^h7^9{c!rV_D}u-i8_)~`{Bud-kYw!c%)u>|Ic?WW?%p1U;gvD{XZXM{m@Cb zb<%fJ<^wdoIcU7siG({=DB>)_Fmcom)Q@&9;RjD7?_=2stn zbk~sXtjm6vNxbvPbZx%U2k+gY-6PX`*JkamiTxducGslp(H~cz`TEB(S@oUd>)_EG zCVdW*J~w%%uP-+{KzNXwcW<)rO&jM=KK$&Lzq!jgZ^kAa4D)w3%zL=kxAfFjZ%x9< zxd!D8A<;e8bmk^uqVxrm?M+BO+$v9JQ~x9C;klWf{x~}Ja{5D&hE=6*?7K}X+r3=+ z#b3&?jxkLq@jrk5&;5V@;(ht)H{QJ4$9`SH@G9i^yG@<{P<+YTLw3eOh7b1YFjKLw zbln-Vw;SR9lM}D)WKPkOUk7pbdj-DeuWrUx_gDVyrJuhX3A;PKoGvaeE@tzkcfVPS z>Z*foSV}nl>O>RaC;jN0%%1!Ce6q1MpZnKuZB?C%i#~cjyNZgRO_y_Hmsip7e9@fE zPPenMTrQvejeq%R+`4x?`hI)FU(6>+0SOuf6hjxk@w#@Fl-EW%Txg3)?d|}=61MMRo``pbH z8TtBRIh&hP|HUb`eYv{7v+Y7!@u@%6X6awYykgq`y6#_PAiIXFHwOcb0+F`U?H01h zQL-(DvV{=WZf$*fJ*EG}3EpV>_2Uo!?dgjrH`L;6_5$!Q3xD#=e|3^)x78=Vxjy+V z^`R!_B;3{&SCts)kehIEtiMkbSw8v+arg6!<;z=(AANH>n%+`oM;Ls&fxrW8fQ%2-z;`Cm6ZR=J`-*Ic-UsM318OG0ieOzep^ z>L`XQ@O)+#(IWII0FOrt-vY%US74IlIy26+NuvW#8l{GBjZQu{zH_EXZL5P*3!j%d z?yO5}-sn8qDyw~y*3GttDOKNZFV8za|2wSNnJN?}Q zTyAU-OKu6PMi0LD!$1CEaWObhe~4YxYuXosGqoFTjVSk_+c7P}!p|pHqJQn#=aa>x z-xa49`VC>nce1C|!0jop=eXt>^AKX{^{P%A0An%l=#cGsx zny`-8XNVU&4nR-tBbr>s3>nv|@!kzpy8r%5OzU!;T%t4og3_N>t&Ubob%ab_>Fg&L ztZ&n%sM<0Kb;ydkF-=z2MW^HX-g5uNWP-Q!-YuyOS3OYbD3+{EeHu!gqplMv8=Z%d z1Z9>lb)ZcZI@+sK!@4%D%QP?e;cb=M;-`ksg4n+r6RhJQTiWXhobsxN#uiD_Rdw0c zu0SvIwsQq`uSl!RH@3?vo7>iAIpT=w@_bc?q;{tBw+r04cN6oOR&PJpUTyvA|%DEAqPSx~}y;b-oRW&gZS%0Y~3? z9IYFdWR1yn^mCclWmcKmv^td9c$4ZFm!=C@+F4_)O-!9OHtEvR^G4Ms?x)Igr*f2` zSIR4=*{*B3pRaCz(%;>I-B*yp(xoYGMC}V5yV&UH_9PEEPKK}Bs!0lGO##X#PKT6m zzw@qYvdlVPTGMSayRB-*4{JVZw|>S^8!*I|Jrd66X{{Lt1 zO`GdVk}JXQ^($y;`k9)8a8@NiGQH6E#0)y&@WEQ~to(|+TszULjk;y#V) zV_xOUfL`%t!(5Vjzmnc6QCu0C94MEI;C`DfUL$4Ax#iw_wv=sJ&D28*X#>3{4|=Qg zUBhQ9RC=y6>1@+maTs$W@4q4j8Cs=#!@->A^6oy~EGOf?zJcD|L9ctm@Rq$Jn)il+ z*GyeY3tc1kOd6Ex7@AUAg&AJ9_MV~+Z=mdb{5H@#H0YH?7AG$_R;&|mNJ(Ie6Kg3l z2_>`8!zArFj)K)A-a^v_NA=cyJPrVQ`!uSD1$w!$H!RmSN5W|>*5G|>LnJ&90~2P+z$IpBCNzfz zZ)6LXYmd>sx$Nk=&v$e*jEho>T@ZiZq3?OD>_nw zGzJ+2VJ$PvUSuwA%iBIT)oQC&C0wJ?zNWdjXAr#KiJBu1$vwu%GpE&8S4kcEqGpap z+_O=}lA$CyBpQmPgSAyf;NYdU$39WRj9?Dilb91Bkn{pO#zvT zYv!@=!q(CwpQtn*%0vl+$uj7ITzN+?pfhrtW>9##xl3Kh{D8?FtD)hZcTW6f9~vCQ%4LciDA?@!Zp z_2qxL$$Yl{&ifYh3N-yq;{H#^H$TeyuRmaV%h1M3P>gD+ISuF8;VKCdk|>u2ayS~q zyGkv!j4&+0JVJeG7R)$(v<-b-Lock^9(K+;TJ^L8zN4 zcid_V)6yadk&S=~WpW5bQ()h&4Fie=t0MOt@k7eBhtI@#@4-J{6+ajb+iQ@xM0x`= z)!MAWmIjqcaNj*n0pX6tW(%!P-)f6_d0xxhjovL{wBGOKehi@D3r*_2M~E++;R@Tvv3YgOM<@T`nS9S@a2@~g@?t&j z_pMUzo}-kYEXS1Dq>WWX)GS7Y0|5t~leJi^P%WV{mQ#{ZVqZ;G?d-b{t8F`qci&Ou zVNilSa!t^XYfj4@R4Frt8ekqkqlVVf6Q|+ZRx<`7uqY4!iZiWWw4?auM*nSh$o%na z_O+Z!Y%|13Ym!=7vt*t@Tgu=@7|=X;M2xIj3>t0bqD7d>>e9>(u-UiI`F>cNeYLlV zv7Vaps%@2IHN_E2ha2hKdzTn-2LS5UdUq@ymRqzo$1<^qqd4`4s)^4!i|>_+n|+;S1iSh~eCBl?2Vl$c{2JzIfV z6K=$-GD6gG$X)E#EtdB8Bia5#6HaGU{TepV}3wVhe>f=#JO zj#j&jnYyrn_G^d4qm97doxtb9vsLKlXc8Oc5eH=~(m4v-Sk{Y1uu)Esr5bf*NsC4` z*lX%x$VTAbP6BSNjzMW8XNM(Fr&LCOUdKZkKrU+;6_%JR44!-Rfl`vrLuBji zbG{!~wjP*!?8aP1t}z8FofX7gi!xK_DiBXAR*g(>y>UrxRSiU*tJ&P}Xv@~S%eopS z%W?oKZCo{B@t4YsRV6&yS~~^Fxhd7ib7C-|HLHoX*e7Lr^x1m3s8ne(7d%Q1WvP_9 zDvgvUSpfwQu5e2g12X)G1ctFFE}D(wDCKEw0$pu4-0LPxDK&*|u+>_6A>kN8@IcKV zKO_du9)V^R(sc??25|Jww7Q>bYs&F}n=p6Iq)l8~TS06RYlCg2850pWW*A8T2?9u# z1>|UzrB4xZ=?>KhZMlVZHl@<$09Tuy#%5r68e1UfU-&J}%0Jc7>v4wWoLG6W-hNCDztz*DiMYqZ%tEe4LY#Rzr? zRimQ;bhE9E zw2|pOlj)X7b@WxU^~AvsE`wGtYqRQHiYdS%78)5&3bWvT%dBIf#1#H_eSwUo>+{U^ zmC-Us9HC9vW$wL|qL%$=#%P68SQE~Bl~TZ$0u6@v!;+ei+EhGX)dG5$U~ddBE1CZpR0CpKO8* ziDLyTs=e;iZ^9U_5Qxj_UO|V@ozHQUiE-3P!f9;6z*i?_Nl*j~OxpiVi-&pq>vU?a^o~-$Q58K%E1o(J)Ay5IpjaJ1%91kJwak5o4mgUvzmLDsMDPYkh-zLdg z#ahGE_bxRNyAqH=jffYo)wn;%w8vj!Rdq|I-I8g)w4yNbbF&qav$mEp)gF?nKxxb# z1C%GxG`JJd%o;<;%E@{I_wb;pY>HyfiUPJN-C)BaRWR~8XH2tV(ZMB-nllKVj-Xkm zmxq`lg@zV*lMEz~`MAzVOtRH#pd6xl$$<>3T(iar(G@ZopgB!$fHx3_(pThyYazr^ z4db(t|7#Hx_c*}!>oy;Phbzg?&vVCxwAqu!nRL7Jn#nP}Z#g z*}?00XA6Y&0=0%YtIJzDO`hc3ePqwbOPETjL5mj%4r@^YScS+GCZ_ceb-edzR1Ykr zi9(L*5$@p?5!+Z^kGXr&1Vi)TR#$;)E>>1k3Ed!;CM5?$0w*8aM!}ZSbcbw4Feoa` zC<>6jry1~LkA(G~#~4Ibg+agkK#gA1bkt~_zY5&qMv&J>53scf05Q~Li~pzUL%3w zZBmgffBDI01yCIz;6eS+d+cpU;TG!Bn3LzxibNf4P6+vRm2zSnfaZY=CfD-Ue4ge| zi*z$GYLbe2J)_r@G$mWH2y1MRyD-}kH`4Pqqln4s=n7MAx%7zD zOQM5R>uefJoFT60kIz`AD7TS8EwT?~1H(8(gkz8M{lKa&7#jr|xG}GZ$C-8745?@q z2ES`r$I2raxLt)eHse=&r{K_Ih;wiZA5*=cgyfKYn`ubl154cW#HiNpOqZ)ay*2Kc{RtfnddmR4euRf?+;XR&x(em-}WclO!&!381o}IlZ6^NDnK?=v|<;APZ zi=RF}h42ASxVW&h6My}`{^j5O?TbJB+aJzf{Y!X0e*f41{)gRA?SA>27gvA%)n9x- zG`{Eat4)}NH+p_LXw3xF}9Bi8Y{&(y^StLKAU*+$6P^IIYU|GBIGA* z!60HtD}ZANmsmw1EwVsHZ+qGRq(EE0hgN(eL%wNVP*gqpuFMF`WW|+~sP&~#glpF2 zi9}T`w>5de{HOQw%!deb@6)Irmf{Psl+lw(sUgdx5mt{ed-|_bZ+GN*Mz}z_!n1d4 z380u4d5Y<|G&7NK%LF1svVVC_INUQan0T#i}(MaLWv3mj|>y(<9gW(a893Et>;=#0o=(8;w z%{RsdhZPxgdgfL&fB|&KSPdD#G%V-fX|JlGQH_z8kyLFDZ*ceA!hx3NQhZI9umYeb z@fq61O!VIpEc( z1;d5Z1L!kvLgT4N*J=Q?Y2+4bE0LXNd8y1ryj&jS-bS(NDRDhfFg)I;42X*~a!IyT z+1N_f{bIJS@UaCBR=LCaD$DZ5eq!FEkw8-+r+Bq72A-Q`Kmi2KRO`S1jgX(Z^D4!< z0k#08LS+F2rk5ojeqLgCkdRq`3dGddqveIX*5ra`69X34P3LdO@F`?SL5+9kOyPte z0EPWdDW}!atOSfG44rORiUe*^@-X1Yj5+m5Ep2jWANwvm{Jd9)OO#S61a(fmcug#& z48V>lj}lwt0UwZq3EL{Qrj!b7a+5=c&$NrVhO}E0&_1Ru@LWUUXlXQ22qB$7_8iBY zy1d)nYF650&1LF5$iB<|jOu~OAxjW)-c_*mVQEe-QWlpoL16o8vsv%S+er18)w9HV z)4{D5aHkk(lSA9S%eL>b?YnIIF5AA#w(oMNeU}O*#9m80>&V_hCVBZg7qE>a(d+=A ziowY;JC9Zb&z0H%Ogt(r-h{>;_FWRNtLzFt_Uz5#L0d=mbMbuy;C(l4nc8SJ*|e4w zr+{rG4x@~sTY}fYg~sxXt^nc=H^Uou! zLsU24r%^pDq0s?{+QwXUYMaI35me81G^A_CZ7pe#ekvV4pQE4CuFXQ#o+kd^gvKT` z?y&S5xY^9AWi6sY5EePP)__UE3#3`Nt~J3Wa^MB>t0X2A<`{iw&_{oy$9qXPk7cw{ zAjD)vFW*p;&OAl^v|X1m3S|k)=1}r=TCABU@d~yvin}w42E$8*R}Y>hQ$sGs1?(2q z%2@BD-YaW)^aUQYmfV_l-<5~|#H`uY%H*BULIgfGpeEd5geU`Z$`nHrQ~ zaNpO0D2{lR4lO{0_^uW-wzAyp^8CHVj5{xhoMRCJrcAs8D}eLQ2@bev6hjC zH^7q^v=2NSb#7hLH?Y6c=qU(%mDRD}V~&H9fiq*J2P>h3SsLi&>JT@BJXtaEY^{;@ zX|53Z;|F`5D|^lpuad!wGzLj#&_%Og;d)X;NT%LDz1Z*ujM3981ph6`J!~!MZ|4nL zO(Y$Raw`6{Za|#QQ3o8M2&K%;pm%!nGe;{Ek(5lkcA=4IJ%E<7PyA*+oFUFdUBBLtY-UtK3~+ za4T#wX3YxhGsp~x{RwB@d$wK3Q+b!nWKsspmbSB{?QDa4i@}XsPSiumiRvz<5}WUj zQ5v8fl$13jZb@yz8FrKA^;BZoMlbklL|a!Y=MQl2No9h5ouO!j5XeM)Tql# z0~i=a8G{uz?GJwa`6l)~hZx4$pSRHvPt&(hG6i;48 zw?yCsspm=-dRkRiwOC@}>>1Ll(U=4lT7ZhFf`pTbkQE4qk& zcQtRgJ0RD<)pl8yC5Du-%0Wvo0ZfIR|XM)Z`t71Ep?PJQ*V z0IOKDl4hKJx?{J>qCC2-*(h!$7xzF)qxBiRA@mfAnTk@`N9YA=fZuv=9jo!~mKi!KBzM-W+Ix$gDcR z+zydHv(Nc{VD;~n^O_xOJT+CSV2Wlb_t=9U*3(hF?N9e@dyR0RxTj!VQOSTadDM+B zZV{+Eq|ObKWjV|SbJ}GgPyy8$g@s33i+k^$vjxM942WxChFMLt#Xc$1Y?Cd>~MiNHVA({i(r^h350L|f0romAD5bCbDDFm6 z?>Vd~oFo8ASPG@y8s*mGjAhi|hX(S*QdU{r=JFc*bwLI}?0F}1D7?5ask<|&G-K6R zX=03%Ksm$06pj%n3o@@6eiWleX%(n}nah&cvf_G~X@V$hdwBmFu2vVj7eiHr~=Rug9lByGlx<$ z*ez6rfssHdSIZp@+eHX#>}2!n2hLyvM=a$^_oy;BI9CKPxm0CO69n+OUQxLXgXV-}EDQmRMp=Wn?Yv zd9|TXSq!TSOD(X_Rwi&C`;?xSG0DJ4d3xVY_)RMe=nAu@s@{iUk;T~N9Kx$AsNqUr zTEjxLwh4`cZ-#=NNhu&3HBYut-G>*3|JE$ASFeI?HHO}Rlx>lB+~}-z&Eh3S^bnh& zdo-$tB{atDb&VVx1-S?%$UM*!QA`9kqS>v)F%-9zQ%gcbxO9b(>JlA!6BJCb7Pdv+k^xCZtmSK?9UhXV*v2DG^q#j1m5X^zuZPCYcLzk0?&G@bCQ`yjiwVs z+{Ft6R|a_cxM4M@Ys)zKUH#_OF&~}$hiCFVpPk#qf4sa{&)+L~_WK9u);Xk^pyXtf znfh1;B&$#=s$R)a3c>03-gHsvxhSs5vn9x#T4$#zo0hq|mYGpX&b>gUN(5mL4Fnkp zGZhHxXfcVlDJyxK&`BD=qur7T++uMkTh8S>GGh))ok$DePimTzMj)R@hF0iaRu{w` zAhA4xk$mezcywlsJggr;X6$pmAC}BW7E**_2+=bmRH+y4qxu1nGDA}@OWGho#>~4K zu^qk{%vmWzY=B)qb(s;9L6g-M@e3%Lv@Xe2X!aJUt6PqeAkd%@OU43$wb3G&mA6o%m@=m> zps59>6JlxBpv3YLep*rCt1th}tzt`WgTc-UJ{eMa1?K^f*v+ngMYwOh-!OD3pf_H| zepgtVgrT*Agu#P)ENhMx;o+-AC|aHjXA0Hl8);#ALHt98q3;@Ep0u?3moLB}tndIc zS6+Fgp8QChGIg(Gnd=bT+JZ!b>B}_WRukLGjc?_~Hz>L{D4KbCvT}%Al0wrLcStED z(dC;xL|!siHI*`G&I&i>)$XR7q-dip{eKVos|p9IYME*%ky9X8BRD{T6@oO92LXfD z=qIpa=*$+e!ef_C6|XOw{yKb#f>}c=k(yT-D|L;jT+_;(1cIx2DH5Kx0-ot!tz`5i zi$UWA8t5S5@_icB18d&dlb>fO%M)+>d?9$0-`E-F5 z$oJ1rPmX{5v~c+Ez5)6>H#GP1x5#F>&L*xhT<|0u-|5*05Oj2cxj)k1zOfvv@sEI% zzxk^Vx=QiOo!tl@A5WG)zW@BG$mQAD8~q34`ykii^z!1><;72*pF;Qm$}TSK?8IOH zuYdV>fBWJO|MrLTSN{^8kKh0GzyD!3RJ&jP=Ec=tfAtq1VBzA6*UEtIG-4{pR`waL2@>AME7f`T50}@dwbqd+s`Z|Gz%q``;*E z@HGqm)=JXaiYet8fl(F#vt0mh$;$%Hylk%EhrdcCiG2(&_>ti2Vu`JV`F&?BzWE@x_%ty5>sEI6<(i_OgI_bM-rLCi+2nH9pY7Gz>33&#joW{B7#AO( z|B`Wh^VMGBBltVJ(U)@{e*V4b{mkqwzR|0rlke_nT=upyy$DuVVew!v%I;lAW|0u3 zRIfyv=3G7R3Px%aZVmX2 z{E}G0cN)Qa&WOCTB>7~n@;x1^{Pi`N9eIl^J{XbJ8VK1a%apuF)o96rMu@0Eo}woN zh_KYXR1nm;cN0oP(GU7EoZ42GbPth5trWcb!bn*wDBUbMb@iiGK58BAB|%`q$w2#rzKm(sOw)@7Kz4fSSqRg-6Cr+%%9L4a*cipu)?{mI zvb8n&3G8PzuCk(nz|;w_kCS5yR%sPuTdS{`GBB+y@9mk!C=KurNTar;ac+3Da2w6~ zO2VX!rA&Q+@QPr0PS9QNwCL^eyi0TQljY5aWl?Xvq^+XOKJbW!G~y6jEui78n}$#- zywVt{>Y5;%o_aodP4HXERxI#RvCZN65F>7Q^mfijOpr5Ol|ipck667VI!Lw7rf~W* z#1;MV8LO8;X~TEpvJYjG5)Xh!`<(9wR%}Ko^6au2#<~|PmcR>a%{;7Vg48Cjqm64L z#vJ-;m(K${T1+&+ZZ|x7;&>!IT5byjrUfth4R)!%ZxkuSoRsiuqv1?)U~rhE=UA(X zfL=1Eyy4LvsuFnh7%bAbs?|1H%$;T%+`*Ka3QUc~dV?<=xCoQg7uK^^%Ad(kZfz0Q zLxWy!g@bp=Ro|e_34AVhQG@4zFreXUq=v43E@$wRJ|qj^g)w!V^C8+z?bE0p7U+pW zR>qbYf8pNn&kPg(t0atb(oSLK6_ZBL=E;d6hD#r{HiCA}TPf$Ql=D`~`GLl(w^Gjc zIJjFW=leWhu$6NDjL;D3syznpsgQ~!ukE@fi3u1KWj0u)`4P_PG2n`IEsHDR5v{TG zO=#?)XvfHT2o(su1{XRy9B5dj7id3Sr8FW8_T*f_5~s~MMcu(BNWhv>*aBZ~r!)YV zdg@++%PVgQ8Hj#bU{E=NQ5ldwa}2};Mc{Tk)1<~_U}ysb!XfHu>~X#ymIlZJ?8-{k zlvPOyo+vLyCoR zlaNQtA&brKHA^$8R8V^;X^RaP^{QzE8ygPhE%P7@ME) z$*mep3X7Ch(K@(zm!=`HGd$(QfJz_E%m{*J3m@!(QS{IToL$9#Z31rw_#6ZngYqWG zu|6gofRKcc1iH8K2n>Uk6yPCqsT-p>c#Oj9on=Zns1*ujXj@%+!~BGd73#|=L&)?r zi~~4%smi6Sq;dFONo%kvIK{%9Y0ThHfu(fH(dH~Y_o%I^z;W41 z6HW}yUGl7;ARD9D7{wjVd3txa#X_S>lN=0md@?ukzs(kdnCB3^BADB zw%lNV9DDa3QDG?zH4c!xR0RsR$z0h6dpGI{4W_x3niWvCW#VqN5AN5f9u}jpqN~IE zNT9f=8g7g`kZ+Y9%a}c;GD-)Rn4>~DYOZFO0Qj&B^rW>hil@E{ueSW`a>)x?IYCQz z&`@vv(!Jd&a|mNt;a&l@wJ@h;)_GPAcouPbEt`?_jo!iCVoXUm$RHO68O)gGf zU4hg+_gZdoPO{yBa8*sC)}WHISFkHwyO1`4m+!GcB(k#7$_?uQe5iyakE_=*V8e_@ z8iJ+YYU!gB&Cns_h$rs9C>BcUHH_7{wh$HtIMyEX%9X;G=(QZTUdzw6Udvw=R?IUV ziFVD}i6o^ZK$ALrugaUZPp!R7Wn#=c2(i`$E79nsMh6UL(^7k=BWKH-GnQJR_`MO8 zq+ylk2%`qj^a(~jGrYEEem4wc$=>0ITEOe*-K2ykpWH=xnn1JE#1R}?*NmXi;EWx% zJwh`Kr3COLk&u%Y(&|YQ6@s6jn!_PVyzOzmA6WAU=tPWgZ!K$BV^sw$&60D=-J4!V z_>Js62rUW#CHN+Isw#uPQ)JtU-DHlJEM@k)jZ&az@DtW6rI5=^v5QrRXPsl_lA)Z7 zH#8&igTzIGjqQ~EK9Y^qs1<1mJTT5xQuH!ZJhKx78%DE99p1)<#p@x2RL2C<_I>Ua z*W6-zhXy^kgC%gS?AwGPb&%ccjqEWQrG(jtiWN&TGP*iT0D z9*yc@fnJ(GXDOAa3~C&qFT@*Yj9BxWeZ^^6*o(;v;IYIR)0}aJGVpgOZ3De+x9|?S zx0W(0!F@^rAcE(HRu=7!-;|8UJ4~>zBC{5fR$77&$kSDwR~@8BzguWUM9uQbnmp@r z_UhTpSgNf`?VL)NHCS8JAS1<0SkGbc?9(P}Z(|gD*e%>O@w1^R^jb#i*8S9c4xOmt zVM@z_=TM|5qg8HIJ-fs=pr-4FP2s+cH)Ay!42|U_OhcfUu)vc;PV+!s7|8@)A+Z*( z`(h(x(ir24oL4!>M&2Ih`+*%_s@i(yoI;HpLe3FP3p{FY_cO$X$tk%e48L*!)Ds&x zjAXDMlNPr+avRv+=`gp+vJ6IV4VIWnpyCZs!I^oqwYc{#oSTyONOkm@VOA4>Tc1$L zk00#0+M*H-i*r_i$nnz_feCb|dEvg)Rw0#KR~cBs22a&fYLR2pLFKW5y-VKz_)P6V;d$AkOUwzCDuiqctg&@8#9_b7!80g$)Sk=!WKmcf+ zMo|FzYvuxOpq%^@uaapcyh0~sDv%z z`s6_m>_0EjYTi7pcNl)EE3`h^jJ&)wF$N&jNe~U*y`Ec_GCgwI0}N@~X8c;49c`eu zbyWH~J1PO}BoX_OOD*n~d&#MQug7H+7;HV15v^cG3UIE@imO28!APLFscfLPMIP_4 zt`diuuyACJ6??}L;fu;BelYk6tJ z!d%M(U!V;$cvIIDf+Pk9uf>vZShH{o2EHw2Y%+RlSGCnNdbZUxdR^Xs)CTq5iTpt3 z=u)encJ`95cqkjLFztK}U{|&!7`pr+@A$uxKEI&Mhk!iVd7BO9<302L^C<(6m7dEWR5UZAqP12k!v! zCFO94LT39!lH16L|L%(McmCbn$KT={{dKJA>TErp#E4*tzW?;m3E0t*{`L*GDj|Oa zn*7aQU57P0-pa?vV1<8t|M^pq%d@jL1rR`PKRD%mdU^5c^5Un@Pa%9@;};ipw)0&7 z`j>zAw=e$iZ+|#{^)KQ1`2Ao1`yX~gwfp67UR?e4SAX$=*8ZN)uR`(*Z}j}!&W@aH z>_YSJU;D$+`D;wtt*6U*eDrQXgkN2=6c1T1CRPy4Sf~wKHuGvZq*Zg7ad@$q3HlvM zF!p+Lp>wb~mgljRunT@~`ft;JcStH*9(5=Y;x0Eh#7uL9*-C3;C{Y$ahMd>*iW;E? z8W273;j{L&)G9xI{Wnb%@XutxFK-sL7KPe@4q+4}_Jbwh1Q5p!I?%&qJ&l-xFh(}5 zP5#^Z#_?6fDkMv4B9HqB`>hzVJ;IaGp^!I7Om%Vkj zmqXwAuiioj|HQK$&^!cl;LD5eKmH*ncKxdaU;gr?o&CQI+&sDX48~oJ`D0!{Cb6ax!?2)^)AGtF_?{BbN`j!nN~v)4{sgfL$vZPcP3t zn4i}>X`pofXKkp^}71rXO|jfO@ZUHbA$OrDR#3|2jfg4WDMqKu4( z;Fod5Xz42(v3U0p8=B2Pe5_g#M1rjS)64-q!CvR;E^rQF&9hW(r9Jh>#AK~kU{2GHe&gMPrLez z8?4%E$-e1#_V-6;P=rT6eAH*3*#-F2yT1DTXN?s;fm#0k-=5hY@Bz;qx}U!ulGE43 z;%z|N-RS3J$GSzz$Isv2&%}QaSA0kF{rMB$?88ZVUBLOeYd$BsKELyQbm9_`kN@5T z?{#HKN1lFQXD^RVa3kN`aH0H?vAQbiesSladRHs+$&dFsp1;2N4PH;HZ+m+u_MK0} z-#)uIyR^^V{yI84zxc%i@NvSAXaD{`|HFU&-GBZt+2Z#P+cfRZa(t=w-*zK?ZIOz9 z`p4h??$foze~EeTXZE+*z0vIc6JLCP%lSFC?_Qeo^6Q54&2!fe)^!O_Z@n`H2I}Sb znm2woC~;vgUmfFK&%e3m!vFp2n}4u}J9!sqJwE-Doe7`Y^CSJ(=fC-ySKs5hkN(gI zZZ)~vYB~67`Ct?DHqP#|)a`YIW}e&G5Bxeo@|!dM(>pPOKb`EhFu(bpU!9%)`E3yP zRwqu&Ucd14Os{fyo&3Ia)zz&01OIsSKF;UfdHV7U#M*uy!{@$u-rEBH=7P_@vx|?@ z%d3F%EeYo9aX$X%H!pwh?LYelpE7|j9`ZSOcw=VOG0AeNp6%i_t~zwPSk2j+hKxZm z3|WF}n4{=yJtT@Wa#YFj35GXTfWnNaM-%AqkS%%j<|<`etthHp?ZC030$f;G4LE@)sXK!VU8oVm)@^U7NG|nEQ>x{FKJ}-6fyt0|~^e zSuB>+{J3ZfkbG&z;U!CBwLmqOJW_UTobw6|PpftBbsUH%=auhO@_lT??h=Xl;N$QK z-(P!z`L&2T`{+yGc%|$0;`?6Ym!)WwLEh7m7l}6S<0#&tZ{g=OmZxKMJRdyVGr5RS z$TVm~Y1Xs$_=Kh>?s0m)q`be<*E@m#GYxtu(*9%L>cJ`c4>RF!N|xv8<%xQ4`=1H( zbvN;rzF$XwzCC04xm3e%K0-Qw{|of^-oE?|<-p$W@src;=R~jo^`9Q_Y~K1FKkIik zDz{O&8|@Ia)<%o|C&e5>7wXR7ViA2Zl|O#-Sun@-&v!4lJ%B@l?=HDp80oGK<>M~l0Dk4} zb8&MQlg0ycG2fq_Upzmz<6R-9=WmAdVR)Keyvl+mnKkm_QbwPaDcWqS2F1fVSW*q} zKUJqR?Pe@e{4jcobg!P~GXr-!hvRQ{PvY>`w-iD*-kZFswv^sk36sY|J0$)JBo;Gq zE>uHfZ+V-&=vE2QGQcF-ni^{EK~`V&Db8X%*eu=?gn3&03pqVIzmjL?pT)5Amwa~d zT=eAm>8q>LShs~TAN_039=_hlxRz62TTsrk8h>ji=SQz^fAR6TT^CyaY%Ke8gx;%l z{OM2MVg!zV{Px5yJ{G|L>;?WV7snXBZ{_sm$1eK$f@_}t{bx(teGugaA-MOEJ-=Mn zE2SF@?dQk!+q(|QCq2bJ1Ni^=Prv&w|M-9Z_M7_?bq|+=-OQQXn1rQJ9w!OAJUf1V z@un!n{@GYx+9$QlLE6v|LM$s=Pm60<)ys&9rJiEVEUdUZwwa<7WiM=C8yovPj^CYa zabK8%HY24V(dz;!&uVMrg`XvR=eo3vTgc6F_tXD1Ortfe#J=Xnw(c@Z_sFJh&Y(8t zv@xeg&zznP^ZDk1krf|==L#qO-BnV^t!c{Z*P8C1qO1^iO&V0ET1ZPdR+bdj=*ww~ zRB4njW$Lgvh*pndmCkXMCifdK`sldrbszgZ;s14|A%xZfub!jklxcW6Nb=Tys|VrG z%W54ICe5DGn!61JwV6v^wY1)I-{$Wwtmojg269Ya2uAqhe&j8F<5xfb>FQsesc_&l zyI-Cm@YzJkTkeYg`X*QXX8#+@FE1~CF0k}f?Kt1ndN+{1#>rPNGS%lAvMakwp-R=% zXUNiX$fT42-MMLQW%?O8PL){#lg_qc*_`~B1?kkmqiiG_S(tJTVZ<~e#|XAXITeYc z6dR30ik&cLpjN$F8AZ5h-RAGB0%<-!x0mzy$D0H7n^$aLeG9ODJ!nTC#p$0fc$g4< z_gV|@z3?uw`DQk|!SgllJ@ZV)npYv}Y%@fOK;0;7q@iVmMzLFsbM%ln%2-oI>@ki? z8s=lr&|d_8?@?pjNLt<6Nk6LO=uP$9*`B_fH$6A+o^oN&F<^Qr7Y{6r&9vm26L@gU zJz2F{vWKo_YB{awh0ZgltZ~UG;LA1CC}n!9Cb5$4w?N3}$8J+TKV`BdvN<4o(p)K7 zVXZxAl4VA{r%JW9nRA4cO+%Wupc#IJmNv$!woT;MDS>vqZ%^QqZU-U@K!`(x?h4p^LDOCI80QV=YMh-Qrwn{N40K!YDy|K+N_i? zc~Mv>?T)llq(asED40-?+WIz84;;vE4&F~v7JvPqduD$+JG%JXTh^gf-mLObC~Dz%U9lU?wu+d4?nZ`qv&^o{8!JrRQuuEk7d8&`A zMx54LN}A$|Yl%EnPeD&CLiNeu?>qYW;~}d3MWqgKDtn7c-7+e*MTwql=E_Ic{}$u< zz-G`%JP7NO-W7IL78iaB$jGC7x2EK3y|Mj=ugrO>pb znyR*z#_VOLI+BKgOQ2tcsBQ6yLrs*08H=q@MOi~?EO31Z%Zx)ST6*p+tR%%6^~l-k zZhN8+YrI;swZ#k$G*N>sr&3!Fv!)z0^fI!w+Cd>2h2X?tY3pfVSiRmKS<{u9)R}8p zn~p!!MAd0kS4k_D6-2e@kco9=M7?pu+{{!2*H{}pS;^dT$SnmKW#$&2=tR|nPt+`_ zmmZ^Jc)Sr;r50ipuaS*KG?tRa9;X7dGUf*aeiua#&1%SXJ=KY72cIa7Ov$(mEG337 zn_*G6si9Tya1U&Q@O4n}0aZngT|+3Ak}EhnCijU>R6jiHi=-*)9MHPc+QI~_3Se$ zJXdo)MTxD{WFw@hlL2M&L?`O-f_KFpboE%NW{!cPSALMvuwHsf6MnEx8dZkWSUW(e z*4&z!M&n>{KGBIfyx^q*naf;q3}Mh{ZA4G^wt!`(QfpHP+gSsA@%pCM*?TRIN1*tgJ$Kq{Luq1s+bpCJK4QvoiZwAoH!Pl-fv7bfOL~ zcrA~*Jo=hfAWIccrD~&lb{t6G3Z0~QMY?I6IeUb#k%tL?`O-f_JSp6NGL{ z;Bc}F8e!_B(Sow-GlUs(FTA)l;V|=}45V6<=47vM^h77>@Pb!bpA1^(IUewUg9P@XD1KfK_z20mVu#(PL%VeFYKl4VV^T3pHZ4Anpu7Mxv5P`+U>#XLNQ0c{nV#3;$P z?D@&EzIgc1MDN+yrj8u6dyuGECSnGSh=~{cn@QTGz&8^u9%O=!T7)U=9Tz^;nfd~o z@e(SKh{?bzT9-^%J8V43BNl|k1wG}RK!;fhA@Ay}#g+hC$!2(}bRr%;IDsWpOJw{k z+2*V>_8ChrE!5(TH%2T@;!93ICeXl49jYsj6(ie{_*7@=@X?6`UAtz5cblyyja=Ac zv?JtfUZK5eh_j4oxuo3cBnn^~g6RvTM0u)&A|5_Gfq_?uBH?93(UT#R%LK!yO+&}} zp&UnGEUwvUl$4Sfms)0MS>lkdw=_}wx(+~?QJ_A&>Ci~A%*GH;z$WQQdIu?AzH>OG zNHovVELN*mms}uzAnDsg-E1pl5Bu?5Cb%7(S|S>YGIUajEvD8jBvmiT8d4MSvaKV9 zqGi{ongcg#VVkI%ZH4S%qQKBs>?`!fYpo38XETO`6%)V%wPtQhQfV>HK5OxmOo-l0 z#Uxmd+eF=HD`XF@50C>a8a<3McYQ%dtJ-3TG1rAT$`DZjBo9j{#gM&`*IKD8pjYIU zw~4yZR>;B6W1W0=bn@rVp2+$WblJO|93K3kth+QJ-QDdwXPrLLNA#Mj@esbL-QpFW zIDd6@_4DIX;p5wVr)yqwqi=T2>puJa-u;x*vp?Sct9|N4-q7{ETff=SvtR!*`?@&0 zyuVJYUQX~+v$uQx^z6G&J^zREZ;wttcEL|A5I%9uRX5mAe2c3KKK=$j&BwP#7oWf8 zjh@1K8%KQ8A->Y-je`TX_ua8}1Yy&t*wop(Jw{qER4_O81p zZ}_f$)bQQ!u^lSCEs5EVm45oPVkj+FX{isQ8bYipmCUS~M0m6U88&hnIZSD#b`d`^ zvf|1kvbCpK6#MHT?dPX>mx~8g@A}ORiX9(6|M@F!ZftX7cQ_p{ZIN$1l@itnxrC77 zv=L`5Dk+O)4ooxUJbL8iaoZ)cQEj|Z*-pnFYWI+G>}xhZ`mRFWK*5N}U*my@I$!8WzgXCe?Qg6X#mzTvO-jlEk#BH#x!D zvoumjIxVb{w&OQ+xrbVeg59=5_S6j z*?YI;xQ-lM_ z9;&FKsz{coY^!amYO!i90EzDd5(#{bukjzpZ}9h%{YW%S9`~p`ZY;@z6Qf{c4D8cM z+`Glm!7^vHl-I6_9Aa-q4LZ~k9j7+xD8Z+0(PwNqWDw6<`e>t*-6%lf=vp*F5hRh% z4@=}eBEg*oqkB11^GPx3y5T+L*u_77|I>qvTwD%~d5D~+9v;azGj;g+`0A}k$v@1@ zV;Coh$;lXRY_z`@CF$ev6?G`BunVxk!j3sGIRf=jU1z8}|7=;*$mejHZ-wDK7zzz_q3l9vgd#69Yclv`MNNAdh z*+t)}lqe~V5e|YOK&w>kf*h$jND*8Mnl$_B6GUj;eOda0z0+TE=rfhkbS5M!w!~;z zKR-$kyDdGaEl~F%#!^y^$w#N7?|w{~V~tOo&K_gjJ{xuQLB-b(ulpu)z)7Lr5d3r%4|fX zHn63sINW9o(Memj$!lMh{?eoA?}5U~(YO5LP0lnU1;B`72#DOF z1|yUmX1M*pwIn0^=u3&M6gF4q?N3l2xh4s2G?zpoF?9$W1<*wAYL;FqH*?VF)wLKYvB%2L49`PLED;-ZpPPaC zgTlmZf$g*kXTOewuqeJeIz8AP2F^ceFVBVGoA>iD$e#MAvn=Pq>AN>?PF9W8VxI`G(z^Hr*Ic?4;u!q5!g0PY6tt!=pd>n zCvlL>X|r!+5m+m2#Ah*}=Fp4F-c=s`veBqNGX(It5cJPXVtxmyx;~~QjDl3}oJC8{ zJ4v-m3D`@7&@6g|9GoLhsyL=_rX*+ql|{Ybv$HYS!Cvbq4`VE`bqcl)omjw6=nK0T zs#zPQ(0VKqbJg6ln0;ZyF;3j~80%*yv9Rmi&%e_z_~vK%)3tS*n>bsEkec(=+*m|g zq{==3Q?&5ib1S_wc8y*mjgCF3cU!?J`Vy{=Z97-iGEP~@0K|iHp&b7vi^UlgA?mZWt>^nHPYf4}3-Zma3V*+$dKBH24&a}CpYs74B(A}fo6Pu4U=xR+<1IFT%4SKvH;~; z-fz=1&olBle_p?z{o@ZWKT`kxDdxQ!?N9A)q}?CyAC{f>WI0(W&Wra}3+w-_PJCT_ zvI#~OxVHb!QV-+0aVXJ3EIC<~75m?>Hvi%gq~YoEtB-$|#YjjV9P+yFzqrk_`&jkW z_dQrKSIbkcmd%TIRyezllDD&u`=Ou6;y1j=G%WD<7pqbf%P@a!e&Tq+cE^kN2RFL! z-AGQ{{E#cji5tIocS6EACm-EV@TEx|zA+^q@)+RveuX3GhFTXDiulxW1 zzWym!zTY16f8HG~9w14K30g@_X&gDQA0uJptZh_A_nre4k2Q9wJtj9^@UcV-jyZOp ztN7>CM`$mPZf@N7K?1kdA#$$}b3oTDFb^Gbu%Oe8oCmVEx5g0$aG{!lQA27iH-ea^ zBLDeeJ7C`7Y=f8@n_F*iEyUY#}m;_>ya8Tb>fS>!2V$b8?OmeGIrRU2yJx z4$j=q0WIV@qCWn4+_z(se^&=`KgzH^)?e^UJl~v&XI;C%YZpD_(cI66UYyJ1k4uq! zcV<54bhP7yqLG7=;)@&3YJ0GBFD=oCt9e~jRU)$&> z#1lvMg%H%Ng?sd=Vjm<9TXhB-O(KGFFVO7O3S{auB{Frx5N+9yQ3{;nROH?e0w_9$ zlk`HRjqL$84&XVe%fh`Q$1$*J)S{yrx1(l@Q449VqunxS`3NDn*alx#YstyM(c#JI zlk$R}W&dcwnUG#x2_6egmjvy^Ub5uQhXrTyJi$yJtX>Fp+p3nv3a=CaVQx>t2JyT>(P+gLY z7&U~!29xQ!NW#`r^Ii%h@1sFYsBS89Z|FiL1ajOGQZyBol0vDz``EJUsZ!{b3X@jp zsxi2%0wEctha|R4{XOXd3muuao0)`386JZ&{Ndc(CTI9uIfKP7EqF0^R0kCxw4Zwt zht7{fmI|^c`j4IR+A)Z(3y=kv{;?N zPiTV{24AI(v(N!LCJSDB&gpX=fBNh=gY@2#kv*>r4x0qikgFvocGY9kRIrO^4vYe> zl^P=S>T1s5UB&yR7#8x|@vl!y8OFhzQ<f9FB<^rncp6j`Hc}FqrFFz3R-Ms`j~3x)QXJu_ei4&WAG>z+Pfl=T7eAS zOAt@Z-y6YMt{ozu@Vy3xZ^&u$Uz)&u2XOyEt~QLCsJ%(GolgxY84i2%RBGw|8Tr%WU**k&?T;hyO+nq`w5? zMyM=oM#4;FSnaFD*2yqCo8Bn)g1*K3`*S_K)=Bhv9JhM%Khp4Fuiu`&f4tsEUl9KN+xXoH0DeG$zkl}{Y2^ddS_%q- z8&h0b57-q%D|HkLW;q7O7Qeax4IS5!bXF+=04dLSXKyx)8#q%JV-W0PCRy~wG&E+5 z=MXw&XhpsA9z($~NVQgre7Z`2Jaj)5xi^8Utt;OsfkKg*#TK4YQ=>Jb@UI56$h9U9 z0ilvqjWJf|qlL8UYS3$An646?aQ2ln;?825U!Y;)J{-JtM$ZTKCu7MWg20_1d=ZGsfq9Kn`TOkZ zavfkV<@3#L`D}3Y#N|s|z6g-zyK_O#%I*EE+%~t-pvK-Xk8Uj*3P<~IviRFPOsLu@ zuuDmEWzQA^jHWIXMLnyb$b^o)sr#Z@OHYm)LG{RLFMuaB762(?O~oNV?InmrLyu(v zQL5^42Nr>;$i3kJy;w*cT2$d=kl$JXaqN3)Ep=O(ltPaJ6;0m}BGu8UC3(jr#v5AN zhyyHBm&OBF=9#X$@qH<&S4&B4#0RciKN-O-MzEC5*tB@IXSyCVX7?~oPFck6U2nN3 zEq$3#b-v?h#IC_{67tGT5j>EK4qzPA)|4$KoNj(k@S3P-1FDIlGljWQXpC0}2eB1q zqgzQv!>*=ndCDr}R+5V$7s)=*EZy55ye`-^s2Dv~(~oraj$qW^k0A-1T`}HlK|QKk z?A}JTfUlC7?2q1Pm3JGj_nF#CucqG~t9sNC0rF_T&p!C6$o(Mzq4XvldIRucLHa1}OcDx1 z^y*qKnyc~eRtrI9TeAd7sTGx+tGhNMcg4>6@tZeis4_dTuYmb0;<=L!T)A#?f)D%W zAEYuHuWv^V_M(-lR!NXB)zrr1cU95O1(P#0NuIl?vmd%Q*EG65c%P(-EbGuAsLm|# zqm`BS&<)s=^B92xh6p)Ui~flUDF_&yo_Yw(nEVa}?gD<+&#iP-GFhUu8bJf@;HD&XG zWa=|5)$oja`G&pHQ%NDa06`iQi^gmnrHVc}js{T{lTm>byv1j13hNnA8^lhAS{;jb z;rZ$*?v6zpT?++kN?AhZy9?4Pp>TpQ=!M$%5lq>^gkS<&Q!D^+7tO7MB%(=TIZ z?_m<;U)^aF{~%88YvWsBf|rk{9zHjzQiQ;Z<7jIjttA{&D@c4=neD`w$V zdIL4&z((dqGL)F3u}qDwkxW0a3!B)loPqCJDjP#^NIsM%NFx`D7KC~;0;8K!7!)%X z%Hxbrt!5fQD&=01kJC>)Kbxo)bLa>-fT)#_2?2wQ`XZkNi+UcjHN{7;cqC&O!&O_u zl51!kNvEIKg-z^N&Z=`8lUXzss5w&?#}!HrwQ6D!gAYPXQiAEiXhb*fkey@ip%srE zr=R$IY+~ic_lgOtC*jEp1#ijYmr*}`TT1U%TzXzJ^3|i9MR@v3l5?$XThM_=N5{W^ zzijk(yTEOA;m5^r)M2V0spL4t!?jOh26FiN-RqYhq~&&9@^ObZ96sS>m9sc}Lr3pe zRw{3m3}1|*mY4G8p6z|M^n*2kWGI{{Gji?Bc)w>0{FU z?>jy07rWZ=>X?BCEi}5Aa(#rSqju`kYK`vrknLw8zYO#I?Y+v33M(}k^_tN|AR zUP~oU$8{gal`#copA{2ncN#L+8pdI=<~#y$CT1)}yH{_qp_r$0wGxRouW>f}duYeD zaigD5n#J-ZCpS7eu&LGA3rRyPG)@U5O0fY^Lc=ISAeJzSV#(!51=B2`d}4%pO>YlQ zWbvCU4hR>#r(ycOobvnncR4yb`1Or});A`(Z>~u0>%R@FoA7uG9*4;OV@T}J^!DXa zUf&Hvn}B(*&UijCRp(vgQS%j((&&F%J7cciVO4Ivj#-RQJjJ4Zq~0?Gd#Q&u8?@{T zU*!gU z+t{?kNa%@s!O}V9ssYfaiK=^os+c1t=ey5cIY?vGF+rS+9|`r!AwUvv9ka`c6l04P zmB!|&)+)1q-Hx`bcTtSUfYG&DvZmyax#q&7+{ll1LsWdyGEzg!S>zR{ghmd68?{KK z_eqcTWJUId+?&`E^lI@4N{yOKTdcuDC^)KxM&;P3Fjg>UORl&A%&~Qm=e0HQc#8D9 z=D8-IQ=>-02MalS{>gGbmF3=+<(eK*oBZlXKTV4KF^c@-h1~vnA@NC&??aFys77x@ zYBaQH&=CSSZ!SDx5U!XSM3QL#|klOrcrkpiCprb zK?2`gKz8WJhY{6a?X9S3vWKJ~SR{@re})OiPn~u$fsYnJ2YgKLMpfH{-@E%Uo*C%e zm08#7$>j6x+rvLxSkr^!BFhOa4&M&Z{3L%r{nH229(_a)PUZD@LOJ>R%7rghwnV%r zqrCR!@q(9<%r4%5+Dkw2;_^FgbW?oy`ZX@z-+fo-7hV6&-_8*AdMiB)NTI7rp>a|Q zD1?lisJ0pby!|U%DC<<9)e!vOYQz{;%W3uP1NKW=>YM zlYHpTlb3?pi?-BT>)`%qcVU!Y5cjypOah~gWfX^$7$GE5&oyBN?x7QN(@?3km;#wf zdgHOz+2S~d&I#4Yn)Z^{m*{Lod=7mdBr(@}Um%AHk}Uz+RIFcDtG8>(Co&#noW{F@~PK8dDEk9cVOcucPqa5%s=rDi@yxinH`HC9o_$M z!(bmD-|Y!@2kw5i;C?e*vj*9(J;KJYULgADxwo9K3A#~8p_T1NW^y3}^OY$xM~ksI zQ#Wk#qpOg2r5HrD8Srk;0Jhe_WB~UlHsMx$?i|E5V*<;9gwQ}np#qCAR>6?n=z4+Z zoBCv`$*E+A_O?81Ba}DCZwT#QcIDB*QcC-#pk)%%?)2T8-()d}imbxGn|geJS`%sw zx^D@CLTGNVx8fRgA49J}MLn3_ye*cFJ!a@sZ3*=;TS;5;H1)XD;{$2&9s{o;wF0Ay zA!Df0jd#03rDut$V@2ek!Q0ZL;3e15uBsABv2|NhOY0_7Uq!=bms^@l{BfE1S07i+ z{hs56zB@Wv-xA{Tru)0YqtnATA1wLHjS>DRPnrNcn`^(j7{TpkpX=srZOr?z6oHzB zp_#L#<{XZ$11T5RedvAE6XcTYC-tR=K&7-8fMN;er9I7b-a3A{tzhTw)lT_EZoT7} zkr}uJVCSH=?u^c-k_b|-#uIZ0E>N%7N+f$P=E~&J;xWZF{Nl#Kn?tqd{?%RR_1)53 zo)W;`z2%((800tcTxYw41E^aa#M_O27AR+TKe zSkAC)8361zFAVRt7VJ!3-3QKU^pyZ5vP%hCP)WeZ4zK`Acc@j!*hcL>IvRyC zvAU2UN2-Oft%0)}>*{IY?A?r*=ib%lg6#iyxpJNo*K! zj!iK7#{Fyz(IKYpl@yRhNqg%Odt-0zs|zPpb9ISAtC<)rW~vE_y6Um`thoihKM-vX zzaQYdwMZv8-z(MxH^w+s^(JpWTIpkM$)x}~2Jt1*6ft>}=E6`+3{6bf-3O>Wm34!- zuP>;l#pdya&k&u5YkTD3+e>Bck_{|BaFdbS!<4=x_&*)(u*VxmZ-2oDCk7_nZ-*xS zY^!!JXo0Ps#rv&kLE0HDIJ=*XX#s)xOdVAZkyACFsl9e65?qKp&MopNLocnNIzMV8 z0xA&a*j?%|wMh$Z@11We(wU>)DQ{>|g4Q0J}=Z7yH!^zf!plnMBZr;$wlpr@wacqXBMBTG=BI4>B z8btXhF_5`V$z#-e%%cTctu9o_$hDA%Iw`^Cqbs%*^^AOX${8$vg_4p_W9(!i03~B! zxm8aRYS7NPM&ob^%jgEmoOSGDdj$5)NW@*e1wJgr*<9dC%!xiDMK^HHV5~;g%Od1{CQ*X>Q}*My;(y zIs@7JrDL198lesvOROaXsy#=Q*ra-B2rj4W@@O64AlDAAkLi5Wn_-!QyITb8M=bkn zdj!mIcJAcvm>xWRdxHM%=+}emWgy!JykT38u=1`pKY>I|MM|~6s|!0<2Hm$862=rs zyHBMiR$zuCrHPJIp<&->WZSBy$rEnzgsnw7quZSl394Q~(c+{y3v?mo!Wc{T$@u`B z?5`y?p(u@f#zZyvoSBH6kvIrzh{UROH+Oe$$GG1NLCqcBd&I&2Y65%eZQiAI-{i{M zqg~ty+TFgddz`p+jMYMlPSRs-pbe{QBpN03aX^&8l@_1}3pN5XSC-Z?YKaEcapK)= zyxUf!6YqA4cS&<`*}F*HwbEOtEprT&B1q4i3)LLD7myT08XFnu=e-RnP|~~b?$*ki zh_?>$R>k%c^X|gDr;qTKI~H#jhsWku-yi(#xF4Jx9d8YL@s2(d|MO1X$;SJdD{gJ` zjBvnGjoV@fstVM*w5*kD=#qufsA1G`I>m!sAzezZWMsMd=EeZA{XxE^%=V*c+}1*! z*tY@pZQ6~jB_QJ%J&?<(IV{}?Yj7@AZ_>6{uBFyu>>LX;m(cZYECj|3walSBXg9JW z`5DRF@zEikd`V*q?-8g|szwgI!=N4_jn>Ltdm^FgLJBD3)E0I7qe?kf4y2fqy~5eY zJGY^4d(OEXeNJ4?-03$am{&IibJu0x%+2e;M9%H%{~Y(1Ln@E6hyB�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≪ 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 literal 132 zcmWN?%MrpL5CG6SRnUNeET4sR1MDKqsAL3luzG!$ckz4n@se$=a~?|F`?@{q-2S&u z-pY8Yd2&(LE=DIgTLR|~AdH;7r)0?4WH@4p2{gLEj3HQGb775yRCS?<)|!AdROf1h O=)~+_mb=~oEQ%jXWheds diff --git a/docs/source/index.rst b/docs/source/index.rst index 9233550..ed754b1 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -108,6 +108,10 @@ Async usage If you do not use ``async with``, call ``await tl.aclose()`` when you are done with the session. Resumable uploads through tuspy run in a worker thread; polling uses ``asyncio.sleep``. +Cancellation waits for that upload batch, including retries, to finish before +releasing caller-owned files. Multipart cancellation drains active file reads. +Timeout and shutdown cleanup can therefore exceed the requested deadline; keep +file context managers open around the awaited call. Endpoint coverage ----------------- @@ -123,6 +127,11 @@ and ``files``. Requests are signed by default; pass ``bearer_token`` to use an existing token. ``issue_bearer_token`` also supports authorization-code and refresh flows. Automatic refresh is not performed. +Public, token, SSE and raw TUS transports honor environment proxies. Sync calls also honor +``REQUESTS_CA_BUNDLE`` / ``CURL_CA_BUNDLE``; async calls reuse an injected aiohttp +session's DNS/TLS connector. Public, token, SSE and raw TUS calls isolate cookies, +default account auth and netrc credentials. + ``stream_assembly_status`` takes the returned ``update_stream_url`` and is used with ``with`` / ``async with``. Iterate its events with ``for`` / ``async for``; the context closes the connection on exit or cancellation. Unknown events remain @@ -131,6 +140,8 @@ fetch the final Assembly Status and inspect ``ok`` / ``error``. HTTP failures raise ``transloadit.stream.StreamError``. Read inactivity defaults to 120 seconds and event size to 1 MiB, adjustable through ``read_timeout`` / ``max_event_size``. There is no automatic reconnect or replay. +EOF ends iteration even without a terminal event. Network failures retain the +underlying requests/urllib3 or aiohttp exception types. For raw TUS, pass the Assembly response to ``tus_options`` / ``create_upload``. Creation pairs ``tus_url`` and ``assembly_ssl_url`` and returns a validated diff --git a/pyproject.toml b/pyproject.toml index 79f87b3..9a57a28 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -25,6 +25,7 @@ classifiers = [ "Topic :: Multimedia :: Sound/Audio :: Conversion", ] dependencies = [ + # Async support is part of the standard 2.0 API, and aiohttp already ships in 1.x. "aiohttp>=3.13.5,<4", "requests>=2.33,<3", "tuspy>=1.0.0,<2.0.0", diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py index fcf2d3a..35561c8 100644 --- a/tests/test_contract_endpoints.py +++ b/tests/test_contract_endpoints.py @@ -9,7 +9,9 @@ from contextlib import asynccontextmanager from pathlib import Path from urllib.parse import parse_qs +from unittest import mock +import aiohttp from aiohttp import web import pytest from requests.structures import CaseInsensitiveDict @@ -45,6 +47,157 @@ def test_move_dam_asset_uses_patch(requests_mock): assert response.data["ok"] == "ASSET_MOVED" +def test_unsigned_put_can_send_extra_fields(requests_mock): + endpoint = requests_mock.put("https://other.example/upload", json={"ok": "OK"}) + Transloadit("key", "secret").request.put("https://other.example/upload", extra_data={"field": "value"}) + assert parse_qs(endpoint.last_request.text) == {"field": ["value"]} + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_polling_retries_rate_limits_and_stops_after_retry_budget(mode): + async def scenario(): + cls = Transloadit if mode == "sync" else AsyncTransloadit + client = cls("key", "secret") + limited = Response(data={"error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED", "info": {"retryIn": .125}}, status_code=429) + completed = Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200) + make_mock = mock.Mock if mode == "sync" else mock.AsyncMock + sleep_path = "transloadit.client.sleep" if mode == "sync" else "transloadit.async_client.asyncio.sleep" + with mock.patch(sleep_path, new_callable=make_mock) as sleep: + client.get_assembly = make_mock(side_effect=[limited, completed]) + result = await call(client, "wait_for_assembly", "https://api2.transloadit.com/assemblies/" + ASSEMBLY_ID) + assert result is completed + sleep.assert_called_once_with(.125) + client.get_assembly = make_mock(return_value=limited) + result = await call(client, "wait_for_assembly", "https://api2.transloadit.com/assemblies/" + ASSEMBLY_ID, retries=2) + assert result is limited and client.get_assembly.call_count == 3 + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_high_level_upload_preserves_assembly_errors(mode): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + make_mock = mock.Mock if mode == "sync" else mock.AsyncMock + client.create_tus_assembly = make_mock(return_value=Response(data={"error": "INVALID_AUTH_KEY"}, status_code=401)) + client.create_upload = make_mock() + with pytest.raises(RuntimeError, match="INVALID_AUTH_KEY.*401"): + await call(client, "upload_tus_assembly", b"file", "file", "file.txt") + client.create_upload.assert_not_called() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("key", ["", "two words", "a,b", "a\r\nb", "caf\u00e9"]) +def test_high_level_upload_rejects_invalid_metadata_before_creating_assembly(mode, key): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + client.create_tus_assembly = (mock.Mock if mode == "sync" else mock.AsyncMock)() + with pytest.raises(ValueError, match="metadata"): + await call(client, "upload_tus_assembly", b"file", "file", "file.txt", user_meta={key: "value"}) + client.create_tus_assembly.assert_not_called() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("header", ["Upload-Concat", "X-HTTP-Method-Override", "x-method-override"]) +def test_raw_tus_rejects_contract_unsupported_headers(header): + client = Transloadit("key", "secret") + with pytest.raises(ValueError, match="Unsupported TUS header"): + tus_request(client, "tusd.get-upload-offset", "https://api2.transloadit.com/resumable/files/upload", {header: "DELETE"}, None) + + +def test_sync_isolated_transport_preserves_proxy_and_ca_settings(requests_mock, monkeypatch, tmp_path): + url = "https://api2.transloadit.com/assembly_notifications" + endpoint = requests_mock.get(url, json={"ok": "OK"}) + monkeypatch.delenv("https_proxy", raising=False) + monkeypatch.setenv("HTTPS_PROXY", "http://proxy.invalid:3128") + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + monkeypatch.setenv("REQUESTS_CA_BUNDLE", "/custom/company-ca.pem") + netrc = tmp_path / "netrc" + netrc.write_text("machine api2.transloadit.com login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + Transloadit("key", "secret", bearer_token="must-not-leak").request.public("GET", "/assembly_notifications") + assert endpoint.last_request.proxies["https"] == "http://proxy.invalid:3128" + assert endpoint.last_request.verify == "/custom/company-ca.pem" + assert "Authorization" not in endpoint.last_request.headers + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_isolated_transports_use_environment_proxy_without_netrc(mode, monkeypatch, tmp_path): + async def scenario(): + async with wire_client(mode) as (client, server): + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.setenv("HTTP_PROXY", server.url) + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.2 login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + # No server listens here: every request must traverse the proxy. + client.service = "http://127.0.0.2:1" + await call(client, "list_assembly_notifications", ASSEMBLY_ID) + await call(client, "issue_bearer_token", {"grant_type": "refresh_token", "refresh_token": "refresh"}) + assembly = {"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": client.service + "/assemblies/" + ASSEMBLY_ID, + "tus_url": client.service + "/resumable/files"} + await call(client, "tus_options", assembly) + stream_url = client.service + "/ws1?assembly=" + ASSEMBLY_ID + if mode == "sync": + def consume(): + with client.stream_assembly_status(stream_url) as events: + return list(events) + await asyncio.to_thread(consume) + else: + async with client.stream_assembly_status(stream_url) as events: + assert [event async for event in events][-1].terminal + assert len(server.requests) == 4 + assert all("Authorization" not in request["headers"] for request in server.requests) + asyncio.run(scenario()) + + +def test_async_isolated_transport_reuses_injected_connector_without_credentials(monkeypatch): + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "sdk.invalid") + async def scenario(): + async with wire_client("async") as (_, server): + class Resolver(aiohttp.abc.AbstractResolver): + async def resolve(self, host, port=0, family=0): + return [{"hostname": host, "host": "127.0.0.1", "port": port, "family": 2, "proto": 0, "flags": 0}] + async def close(self): + pass + connector = aiohttp.TCPConnector(resolver=Resolver()) + async with aiohttp.ClientSession(connector=connector, auth=aiohttp.BasicAuth("ambient", "secret"), + headers={"Cookie": "session=must-not-leak"}) as session: + service = server.url.replace("127.0.0.1", "sdk.invalid") + async with AsyncTransloadit("key", "secret", service=service, session=session) as client: + await client.list_assembly_notifications(ASSEMBLY_ID) + assert not connector.closed and not session.closed + assert "Authorization" not in server.requests[-1]["headers"] + assert "Cookie" not in server.requests[-1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_high_level_raw_tus_upload_and_resume(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + assembly_url = server.url + "/assemblies/" + ASSEMBLY_ID + created = Response(data={"ok": "ASSEMBLY_UPLOADING", "assembly_id": ASSEMBLY_ID, + "assembly_ssl_url": assembly_url, "tus_url": server.url + "/resumable/files"}, + status_code=200) + client.create_tus_assembly = (mock.Mock if mode == "sync" else mock.AsyncMock)(return_value=created) + content = b"abcdef" + completed, upload_url = await call(client, "upload_tus_assembly", content, "file", "test.txt", {"label": "caf\u00e9"}) + assert server.upload == content and completed.status_code == 200 + metadata = dict(part.split(" ", 1) for part in server.requests[0]["headers"]["Upload-Metadata"].split(",")) + assert base64.b64decode(metadata["label"]).decode() == "caf\u00e9" + assert base64.b64decode(metadata["assembly_url"]).decode() == assembly_url + server.upload = content[:3] + completed = await call(client, "resume_tus_upload", upload_url, content, assembly_url) + assert server.upload == content and completed.status_code == 200 + assert server.requests[-2]["headers"]["Upload-Offset"] == "3" + asyncio.run(scenario()) + + ASSEMBLY_ID = "a" * 32 @@ -88,9 +241,10 @@ async def handle(self, request): else: await response.write(b"data: ping\n\n") self.started.set() - for _ in range(100): + while request.transport is not None and not request.transport.is_closing(): await asyncio.sleep(.01) await response.write(b": heartbeat\n\n") + self.disconnected.set() except (ConnectionResetError, asyncio.CancelledError): self.disconnected.set() return response @@ -319,17 +473,18 @@ def consume(): assert next(events).event == "ping" await asyncio.to_thread(consume) else: + consumed = asyncio.Event() async def consume(): async with client.stream_assembly_status(url) as events: assert (await anext(events)).event == "ping" + consumed.set() await asyncio.sleep(100) task = asyncio.create_task(consume()) - await asyncio.wait_for(server.started.wait(), 2) - await asyncio.sleep(.02) + await asyncio.wait_for(consumed.wait(), 10) task.cancel() with pytest.raises(asyncio.CancelledError): await task - await asyncio.wait_for(server.disconnected.wait(), 2) + await asyncio.wait_for(server.disconnected.wait(), 10) asyncio.run(scenario()) diff --git a/tests/test_upload_cleanup.py b/tests/test_upload_cleanup.py new file mode 100644 index 0000000..dc52066 --- /dev/null +++ b/tests/test_upload_cleanup.py @@ -0,0 +1,78 @@ +import asyncio +import io +import threading + +import pytest + +from transloadit.async_client import AsyncTransloadit + + +def test_multipart_cancellation_drains_worker_before_releasing_file(): + async def scenario(): + started, release, finished = threading.Event(), threading.Event(), threading.Event() + class SlowStream(io.BytesIO): + def read(self, *args): + started.set() + release.wait(10) + try: + return super().read(*args) + finally: + finished.set() + class Writer: + async def write(self, chunk): + pass + class Context: + def __init__(self, data): + self.payload = data() + async def __aenter__(self): + await self.payload.write(Writer()) + raise AssertionError("Expected cancellation") + async def __aexit__(self, *args): + await self.payload.close() + class Session: + closed = False + def post(self, url, **kwargs): + return Context(kwargs["data"]) + upload = SlowStream(b"payload") + client = AsyncTransloadit("key", "secret", session=Session()) + task = asyncio.create_task(client.create_assembly(files={"file": upload})) + try: + assert await asyncio.to_thread(started.wait, 5) + task.cancel() + await asyncio.sleep(.02) + task.cancel() + await asyncio.sleep(.02) + assert not task.done(), "Cancellation returned while the caller's stream was still in use" + finally: + release.set() + with pytest.raises(asyncio.CancelledError): + await task + assert await asyncio.to_thread(finished.wait, 5) + upload.close() + asyncio.run(scenario()) + + +def test_repeated_cancellation_still_drains_tus_worker(): + async def scenario(): + started, release, finished = threading.Event(), threading.Event(), threading.Event() + client = AsyncTransloadit("key", "secret") + assembly = client.new_assembly() + def upload(*args): + started.set() + release.wait(10) + finished.set() + assembly._do_tus_upload = upload + task = asyncio.create_task(assembly._do_tus_upload_async("assembly", "upload", 3)) + try: + assert await asyncio.to_thread(started.wait, 5) + task.cancel() + await asyncio.sleep(.02) + task.cancel() + await asyncio.sleep(.02) + assert not task.done(), "Repeated cancellation released a running TUS worker" + finally: + release.set() + with pytest.raises(asyncio.CancelledError): + await task + assert await asyncio.to_thread(finished.wait, 5) + asyncio.run(scenario()) diff --git a/transloadit/assembly.py b/transloadit/assembly.py index 09e8db7..b4dbcb7 100644 --- a/transloadit/assembly.py +++ b/transloadit/assembly.py @@ -86,6 +86,8 @@ def _rewind_files(self, positions): raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc def _do_tus_upload(self, assembly_url, tus_url, retries): + # Preserve legacy custom/Gateway upload hosts returned by the configured + # service. Contract capability restrictions apply to the raw TUS methods. tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): metadata = { diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 64a9c4b..497de83 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -4,7 +4,7 @@ from tusclient import client as tus from . import optionbuilder -from .upload import get_upload_filename +from .upload import get_upload_filename, wait_for_upload_worker class AsyncAssembly(optionbuilder.OptionBuilder): @@ -63,6 +63,8 @@ def _rewind_files(self, positions): raise RuntimeError(f"Unable to rewind file stream {key!r}.") from exc def _do_tus_upload(self, assembly_url, tus_url, retries): + # Preserve legacy custom/Gateway upload hosts returned by the configured + # service. Contract capability restrictions apply to the raw TUS methods. tus_client = tus.TusClient(tus_url) for key, file_stream in self.files.items(): filename = get_upload_filename(file_stream, key) @@ -85,18 +87,16 @@ async def _do_tus_upload_async(self, assembly_url, tus_url, retries): upload_task = asyncio.create_task( asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) ) - try: - await asyncio.shield(upload_task) - except asyncio.CancelledError: - try: - await upload_task - except Exception: - pass - raise + await wait_for_upload_worker(upload_task) async def create(self, wait=False, resumable=True, retries=3): """ Save/Submit the assembly for processing. + + Resumable uploads use a tuspy worker thread. Cancellation waits for that + upload batch, including retries, to finish before releasing caller-owned + files. Consequently, cancellation and timeout cleanup may take longer than + the requested deadline. Multipart uploads drain any active file read too. """ data = self.get_options() file_positions, missing_file_positions = self._snapshot_file_positions() diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 91f512f..02cd3fe 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -1,10 +1,10 @@ import asyncio -import base64 from typing import Optional from urllib.parse import quote from . import async_assembly, async_request, async_template from .api_url import normalize_service_url, require_path_id +from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url @@ -599,11 +599,9 @@ async def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_ async def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """Create an Assembly, upload one file using TUS, and wait for completion.""" + encoded = encode_upload_metadata(fieldname, filename, user_meta) assembly = await self.create_tus_assembly(1) - metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} - metadata.update({"fieldname": fieldname, "filename": filename}) - encoded = ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") - for key, value in metadata.items()) + check_assembly_created(assembly) created = await self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) if created.status_code != 201: raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") @@ -613,11 +611,16 @@ async def upload_tus_assembly(self, content: bytes, fieldname: str, filename: st completed = await self.wait_for_assembly(assembly.data["assembly_ssl_url"]) return completed, created.upload_url - async def wait_for_assembly(self, assembly_url: str): + async def wait_for_assembly(self, assembly_url: str, *, retries=3): """ Waits for an Assembly to finish uploading and executing. Use the returned assembly_ssl_url as the assembly URL. + Retry consecutive rate limits up to retries times, honoring info.retryIn. """ + if not isinstance(retries, int) or retries < 0: + raise ValueError("retries must be a non-negative integer.") + polling = self.new_assembly() + remaining = retries while True: response = await self.get_assembly(assembly_url=assembly_url) data = response.data @@ -625,7 +628,13 @@ async def wait_for_assembly(self, assembly_url: str): if not isinstance(data, dict): raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") - # Abort polling if the assembly has entered an error state + if polling._rate_limit_reached(data): + if remaining == 0: + return response + remaining -= 1 + await asyncio.sleep(polling._retry_delay(data)) + continue + remaining = retries if data.get("error"): return response diff --git a/transloadit/async_request.py b/transloadit/async_request.py index bc528e8..e35afc1 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -6,6 +6,7 @@ import json import mimetypes import os +import threading from datetime import datetime, timedelta, timezone from contextlib import asynccontextmanager from types import MappingProxyType @@ -15,10 +16,10 @@ from . import __version__ from .api_url import should_sign_api_url -from .endpoint_transport import capability_url, token_request, tus_request, validate_upload_location +from .endpoint_transport import async_network_options, capability_url, token_request, tus_request, validate_upload_location from .response import Response from .stream import EventParser, StreamError -from .upload import get_upload_filename +from .upload import get_upload_filename, wait_for_upload_worker TIMEOUT = 60 @@ -26,6 +27,23 @@ class _NonClosingUploadStream(io.IOBase): def __init__(self, file_stream): self._file_stream = file_stream + self._lock = threading.Lock() + self._retired = threading.Event() + + def _call(self, method, *args): + with self._lock: + if self._retired.is_set(): + raise ValueError("Upload stream is no longer active.") + return getattr(self._file_stream, method)(*args) + + def retire(self): + # Prevent queued executor reads from touching the caller's file later. + self._retired.set() + + def drain(self): + # An in-flight blocking read holds this lock until it releases the file. + with self._lock: + pass @property def name(self): @@ -35,40 +53,40 @@ def close(self): pass def fileno(self): - return self._file_stream.fileno() + return self._call("fileno") def read(self, *args): - return self._file_stream.read(*args) + return self._call("read", *args) def readable(self): readable = getattr(self._file_stream, "readable", None) if callable(readable): try: - return readable() + return self._call("readable") except (OSError, ValueError): return False return hasattr(self._file_stream, "read") def readline(self, *args): - return self._file_stream.readline(*args) + return self._call("readline", *args) def readlines(self, *args): - return self._file_stream.readlines(*args) + return self._call("readlines", *args) def seek(self, *args): - return self._file_stream.seek(*args) + return self._call("seek", *args) def seekable(self): seekable = getattr(self._file_stream, "seekable", None) if callable(seekable): try: - return seekable() + return self._call("seekable") except (OSError, ValueError): return False return hasattr(self._file_stream, "seek") def tell(self): - return self._file_stream.tell() + return self._call("tell") class AsyncRequest: @@ -181,17 +199,20 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No if extra_data: data.update(extra_data) + uploads = [] if files: form = aiohttp.FormData() for key, value in self._normalize_payload(data): form.add_field(key, value) for key, file_stream in files.items(): + upload = _NonClosingUploadStream(file_stream) + uploads.append(upload) filename = get_upload_filename(file_stream, key) content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" form.add_field( key, - _NonClosingUploadStream(file_stream), + upload, filename=filename, content_type=content_type, ) @@ -199,18 +220,27 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No else: payload = self._normalize_payload(data) - async with getattr(session, method)( - url, - data=payload, - headers=self._headers(url), - timeout=self._timeout(), - allow_redirects=False, - ) as response: - return Response( - data=await self._read_response_data(response), - status_code=response.status, - headers=CaseInsensitiveDict(response.headers), - ) + try: + async with getattr(session, method)( + url, + data=payload, + headers=self._headers(url), + timeout=self._timeout(), + allow_redirects=False, + ) as response: + return Response( + data=await self._read_response_data(response), + status_code=response.status, + headers=CaseInsensitiveDict(response.headers), + ) + finally: + if uploads: + for upload in uploads: + upload.retire() + def drain(): + for upload in uploads: + upload.drain() + await wait_for_upload_worker(asyncio.create_task(asyncio.to_thread(drain))) async def put(self, path, data=None, extra_data=None, files=None): """ @@ -273,30 +303,42 @@ def _get_full_url(self, url): return url return self.transloadit.service + url + @asynccontextmanager + async def _isolated_session(self): + # Share DNS/TLS/pool configuration, never the session's cookies or auth. + connector = getattr(self._session, "connector", None) + if self._session is not None and self._session.closed and not self._owns_session: + raise RuntimeError("Injected aiohttp session is closed.") + async with aiohttp.ClientSession(connector=connector, connector_owner=connector is None, + cookie_jar=aiohttp.DummyCookieJar(), trust_env=False) as session: + yield session + async def public(self, method, path, params=None, data=None): # A separate session prevents injected session cookies/auth from leaking # onto credential-free capability and public endpoints. - async with aiohttp.ClientSession(trust_env=False) as session: - async with session.request(method, self._get_full_url(path), params=params, data=data, - headers=self._headers(), timeout=self._timeout(), allow_redirects=False) as response: + url = self._get_full_url(path) + async with self._isolated_session() as session: + async with session.request(method, url, params=params, data=data, + headers=self._headers(), timeout=self._timeout(), allow_redirects=False, + **async_network_options(url)) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) async def issue_bearer_token(self, data=None): url, data, headers = token_request(self.transloadit, data) headers.update(self._headers()) - async with aiohttp.ClientSession(trust_env=False) as session: + async with self._isolated_session() as session: async with session.post(url, data=self._normalize_payload(data), headers=headers, - timeout=self._timeout(), allow_redirects=False) as response: + timeout=self._timeout(), allow_redirects=False, **async_network_options(url)) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) async def tus(self, operation_id, location, headers=None, body=None): spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) headers.update(self._headers()) - async with aiohttp.ClientSession(trust_env=False) as session: + async with self._isolated_session() as session: async with session.request(spec["method"], url, data=body, headers=headers, - timeout=self._timeout(), allow_redirects=False) as raw: + timeout=self._timeout(), allow_redirects=False, **async_network_options(url)) as raw: data = await raw.read() if spec["binary_response"] else await self._read_response_data(raw) response = Response(data=data, status_code=raw.status, headers=CaseInsensitiveDict(raw.headers)) if spec["method"] == "POST": @@ -308,15 +350,17 @@ async def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): url = capability_url(self.transloadit, url, "status-stream") parser = EventParser(max_event_size) timeout = aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=read_timeout) - async with aiohttp.ClientSession(trust_env=False) as session: + async with self._isolated_session() as session: async with session.get(url, headers={**self._headers(), "Accept": "text/event-stream"}, - timeout=timeout, allow_redirects=False) as response: + timeout=timeout, allow_redirects=False, **async_network_options(url)) as response: if response.status != 200: raise StreamError(response.status) if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": raise StreamError(response.status, "Expected text/event-stream") async def events(): + # EOF is not Assembly success; callers inspect the final status. + # Keep aiohttp exception types for existing retry policies. async for chunk in response.content.iter_any(): for event in parser.feed(chunk): yield event diff --git a/transloadit/client.py b/transloadit/client.py index 993209a..2fb634e 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -1,4 +1,3 @@ -import base64 import typing from time import sleep from typing import Optional @@ -8,6 +7,7 @@ from . import assembly, request, template from .api_url import normalize_service_url, require_path_id +from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url if typing.TYPE_CHECKING: @@ -604,11 +604,9 @@ def resume_tus_upload(self, upload_url: str, content: bytes, assembly_ssl_url: s def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, user_meta: Optional[dict] = None): """Create an Assembly, upload one file using TUS, and wait for completion.""" + encoded = encode_upload_metadata(fieldname, filename, user_meta) assembly = self.create_tus_assembly(1) - metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} - metadata.update({"fieldname": fieldname, "filename": filename}) - encoded = ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") - for key, value in metadata.items()) + check_assembly_created(assembly) created = self.create_upload(assembly, headers={"Upload-Length": str(len(content)), "Upload-Metadata": encoded}) if created.status_code != 201: raise RuntimeError(f"TUS creation returned HTTP {created.status_code}") @@ -618,11 +616,16 @@ def upload_tus_assembly(self, content: bytes, fieldname: str, filename: str, use completed = self.wait_for_assembly(assembly.data["assembly_ssl_url"]) return completed, created.upload_url - def wait_for_assembly(self, assembly_url: str): + def wait_for_assembly(self, assembly_url: str, *, retries=3): """ Waits for an Assembly to finish uploading and executing. Use the returned assembly_ssl_url as the assembly URL. + Retry consecutive rate limits up to retries times, honoring info.retryIn. """ + if not isinstance(retries, int) or retries < 0: + raise ValueError("retries must be a non-negative integer.") + polling = self.new_assembly() + remaining = retries while True: response = self.get_assembly(assembly_url=assembly_url) data = response.data @@ -630,7 +633,13 @@ def wait_for_assembly(self, assembly_url: str): if not isinstance(data, dict): raise RuntimeError(f"Unexpected non-JSON response ({response.status_code}).") - # Abort polling if the assembly has entered an error state + if polling._rate_limit_reached(data): + if remaining == 0: + return response + remaining -= 1 + sleep(polling._retry_delay(data)) + continue + remaining = retries if data.get("error"): return response diff --git a/transloadit/endpoint_transport.py b/transloadit/endpoint_transport.py index 6c157cb..ca736e0 100644 --- a/transloadit/endpoint_transport.py +++ b/transloadit/endpoint_transport.py @@ -1,16 +1,29 @@ """Shared wire preparation for OAuth, SSE and raw TUS endpoints.""" import base64 import copy +import os from ipaddress import ip_address import re from urllib.parse import parse_qs, unquote, urljoin, urlsplit from requests.structures import CaseInsensitiveDict +from requests.utils import get_environ_proxies from ._contract import CONTRACT from .response import Response +def sync_network_options(url): + """Honor transport configuration without enabling ambient netrc auth.""" + return {"proxies": get_environ_proxies(url), + "verify": os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("CURL_CA_BUNDLE") or True} + + +def async_network_options(url): + proxies = get_environ_proxies(url) + return {"proxy": proxies.get(urlsplit(url).scheme) or proxies.get("all")} + + def token_request(client, data): data = copy.deepcopy(data or {}) if not isinstance(data, dict): @@ -121,6 +134,8 @@ def tus_request(client, operation_id, location, headers, body): supplied = CaseInsensitiveDict(headers or {}) if any(name.lower() in {"authorization", "proxy-authorization", "cookie", "host"} for name in supplied): raise ValueError("Account credentials and Host overrides are not TUS headers.") + if any(name.lower() in CONTRACT["capability"]["unsupportedHeaders"] for name in supplied): + raise ValueError("Unsupported TUS header in the API2 contract.") outgoing = CaseInsensitiveDict(spec["defaults"]) outgoing.update(supplied) if spec["destination"] == "tus-collection": diff --git a/transloadit/request.py b/transloadit/request.py index 5292efb..c9b90a9 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -9,7 +9,7 @@ from . import __version__ from .api_url import should_sign_api_url -from .endpoint_transport import capability_url, token_request, tus_request, validate_upload_location +from .endpoint_transport import capability_url, sync_network_options, token_request, tus_request, validate_upload_location from .response import Response, as_response from .stream import EventParser, StreamError @@ -101,7 +101,7 @@ def put(self, path, data=None, extra_data=None, files=None): Return an instance of """ url = self._get_full_url(path) - data = self._to_request_payload(url, data) + data = self._to_request_payload(url, data) or {} if extra_data: data.update(extra_data) return requests.put( @@ -176,8 +176,9 @@ def _get_full_url(self, url): def public(self, method, path, params=None, data=None): with requests.Session() as session: session.trust_env = False # Do not borrow netrc credentials for unsigned endpoints. - raw = session.request(method, self._get_full_url(path), params=params, data=data, - headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False) + url = self._get_full_url(path) + raw = session.request(method, url, params=params, data=data, + headers=self.HEADERS, timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url)) return Response(raw) def issue_bearer_token(self, data=None): @@ -185,7 +186,7 @@ def issue_bearer_token(self, data=None): headers.update(self.HEADERS) with requests.Session() as session: session.trust_env = False - return Response(session.post(url, data=data, headers=headers, timeout=TIMEOUT, allow_redirects=False)) + return Response(session.post(url, data=data, headers=headers, timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url))) def tus(self, operation_id, location, headers=None, body=None): spec, url, headers, body = tus_request(self.transloadit, operation_id, location, headers, body) @@ -193,7 +194,7 @@ def tus(self, operation_id, location, headers=None, body=None): with requests.Session() as session: session.trust_env = False raw = session.request(spec["method"], url, data=body, headers=headers, - timeout=TIMEOUT, allow_redirects=False) + timeout=TIMEOUT, allow_redirects=False, **sync_network_options(url)) response = Response(raw, data=raw.content) if spec["binary_response"] else Response(raw) if spec["method"] == "POST": validate_upload_location(self.transloadit, url, response) @@ -206,13 +207,16 @@ def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): with requests.Session() as session: session.trust_env = False with session.get(url, headers={**self.HEADERS, "Accept": "text/event-stream"}, - timeout=(TIMEOUT, read_timeout), stream=True, allow_redirects=False) as response: + timeout=(TIMEOUT, read_timeout), stream=True, allow_redirects=False, + **sync_network_options(url)) as response: if response.status_code != 200: raise StreamError(response.status_code) if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": raise StreamError(response.status_code, "Expected text/event-stream") def events(): + # EOF is not Assembly success; callers inspect the final status. + # Keep transport exception types for existing retry policies. # read1 returns available bytes without waiting to fill a chunk. while chunk := response.raw.read1(65536, decode_content=True): for event in parser.feed(chunk): diff --git a/transloadit/upload.py b/transloadit/upload.py index 7803f68..e647835 100644 --- a/transloadit/upload.py +++ b/transloadit/upload.py @@ -1,4 +1,42 @@ +import asyncio +import base64 import os +import re + + +async def wait_for_upload_worker(task): + """Drain an owned worker even when the caller is cancelled more than once.""" + cancelled = False + while not task.done(): + try: + await asyncio.shield(task) + except asyncio.CancelledError: + cancelled = True + except Exception: + break + if cancelled: + if not task.cancelled(): + task.exception() # Retrieve a worker failure while preserving cancellation. + raise asyncio.CancelledError + return task.result() + + +def encode_upload_metadata(fieldname, filename, user_meta): + metadata = {str(key): str(value) for key, value in (user_meta or {}).items()} + metadata.update({"fieldname": fieldname, "filename": filename}) + for key in metadata: + if not re.fullmatch(r"[!-~]+", key) or "," in key or key == "assembly_url": + raise ValueError("Invalid or reserved TUS metadata key.") + return ",".join(key + " " + base64.b64encode(str(value).encode()).decode("ascii") + for key, value in metadata.items()) + + +def check_assembly_created(response): + if not isinstance(response.data, dict): + raise RuntimeError(f"Assembly creation returned non-JSON data (HTTP {response.status_code}).") + if not 200 <= response.status_code < 300 or response.data.get("error"): + error = response.data.get("error", "UNKNOWN_ERROR") + raise RuntimeError(f"Assembly creation failed: {error} (HTTP {response.status_code}).") def get_upload_filename(file_stream, fallback): From d3b16ec1e3bb344b6ee17d5b03931fb12146dae0 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 10 Oct 2026 23:37:25 +0200 Subject: [PATCH 58/64] Isolate Assembly credentials and preserve upload and polling compatibility --- CHANGELOG.md | 1 + README.md | 8 ++- docs/source/index.rst | 8 ++- tests/test_async_client.py | 30 ++++----- tests/test_client.py | 21 ++----- tests/test_contract_endpoints.py | 105 +++++++++++++++++++++++++++++++ transloadit/async_client.py | 27 +++----- transloadit/async_request.py | 45 ++++++++----- transloadit/client.py | 22 +++---- transloadit/request.py | 15 ++++- 10 files changed, 200 insertions(+), 82 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 74825c9..7bf3c94 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ * Added signed PATCH, multipart PUT Assembly replacement, optional bearer-token authentication and authorization-code/refresh-token issuance. SSE supports incremental events and context-managed cancellation/cleanup. Raw TUS preserves binary downloads and response headers, validates returned destinations and does not forward account credentials or follow redirects. * Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. * Async cancellation drains active multipart reads and resumable workers, including repeated cancellation, before releasing caller-owned files. Isolated public, token, SSE and raw TUS transports preserve proxy/TLS configuration without borrowing session or netrc account credentials. High-level TUS helpers validate metadata and preserve Assembly creation errors. +* Explicit bearer authentication wins over ambient netrc or session auth. Assembly capability requests isolate account credentials while preserving custom deployment worker hosts. Async multipart uploads retain text-mode file support, and polling continues through `ASSEMBLY_REPLAYING`. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. diff --git a/README.md b/README.md index 752ce2f..4b796e5 100644 --- a/README.md +++ b/README.md @@ -106,7 +106,13 @@ Public, token, SSE and raw TUS transports honor environment proxies. Sync calls `REQUESTS_CA_BUNDLE` / `CURL_CA_BUNDLE`; async transports reuse the DNS/TLS connector of an injected aiohttp session. Public, token, SSE and raw TUS calls use isolated sessions so injected cookies, default account auth and netrc credentials cannot -be forwarded accidentally. +be forwarded accidentally. Explicit bearer authentication also takes precedence +over netrc and injected session authentication. + +Assembly get/cancel requests use the same credential isolation. When `service` +points to a custom deployment, its returned Assembly worker hosts remain supported, +including for high-level polling. The default Transloadit service restricts these +requests to its API hosts; neither mode follows redirects or accepts URL credentials. SSE uses the returned Assembly `update_stream_url` and a context manager: diff --git a/docs/source/index.rst b/docs/source/index.rst index ed754b1..f173c33 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -130,7 +130,13 @@ flows. Automatic refresh is not performed. Public, token, SSE and raw TUS transports honor environment proxies. Sync calls also honor ``REQUESTS_CA_BUNDLE`` / ``CURL_CA_BUNDLE``; async calls reuse an injected aiohttp session's DNS/TLS connector. Public, token, SSE and raw TUS calls isolate cookies, -default account auth and netrc credentials. +default account auth and netrc credentials. Explicit bearer authentication takes +precedence over netrc and injected session authentication. + +Assembly get/cancel also isolate account credentials. Custom ``service`` deployments +retain their returned Assembly worker hosts for high-level polling. The default +Transloadit service restricts these requests to its API hosts; neither mode follows +redirects or accepts credentials embedded in URLs. ``stream_assembly_status`` takes the returned ``update_stream_url`` and is used with ``with`` / ``async with``. Iterate its events with ``for`` / ``async for``; diff --git a/tests/test_async_client.py b/tests/test_async_client.py index fc1596f..01508f7 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -406,18 +406,15 @@ async def test_async_client_normalizes_service_and_rejects_missing_ids(self): service="https://api2.transloadit.com", session=transloadit_session, ) - await transloadit_client.get_assembly( - assembly_url="https://api2-region.transloadit.com/assemblies/abc123", - params={"nonce": 123}, - ) - self.assertEqual( - transloadit_session.calls[0][0], - "https://api2-region.transloadit.com/assemblies/abc123", + with mock.patch.object(transloadit_client.request, "public", new_callable=mock.AsyncMock) as request_mock: + await transloadit_client.get_assembly( + assembly_url="https://api2-region.transloadit.com/assemblies/abc123", + params={"nonce": 123}, + ) + request_mock.assert_awaited_once_with( + "GET", "https://api2-region.transloadit.com/assemblies/abc123", params={"nonce": 123} ) - request_kwargs = transloadit_session.calls[0][1] - self.assertEqual(request_kwargs["params"], {"nonce": 123}) - self.assertNotIn("Authorization", request_kwargs["headers"]) - self.assertFalse(request_kwargs["allow_redirects"]) + self.assertEqual(transloadit_session.calls, []) await client.close() @@ -440,8 +437,13 @@ async def test_async_client_quotes_path_ids(self): session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"}) client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session) - await client.get_assembly(assembly_id="assembly/with?chars") - await client.cancel_assembly(assembly_id="cancel/with?chars") + with mock.patch.object(client.request, "public", new_callable=mock.AsyncMock) as public: + await client.get_assembly(assembly_id="assembly/with?chars") + await client.cancel_assembly(assembly_id="cancel/with?chars") + self.assertEqual(public.await_args_list, [ + mock.call("GET", f"{self.server.base_url}/assemblies/assembly%2Fwith%3Fchars", params=None), + mock.call("DELETE", f"{self.server.base_url}/assemblies/cancel%2Fwith%3Fchars", params=None), + ]) await client.get_template("template/with?chars") await client.update_template("update/with?chars", {"name": "foo"}) await client.delete_template("delete/with?chars") @@ -450,8 +452,6 @@ async def test_async_client_quotes_path_ids(self): self.assertEqual( urls, [ - f"{self.server.base_url}/assemblies/assembly%2Fwith%3Fchars", - f"{self.server.base_url}/assemblies/cancel%2Fwith%3Fchars", f"{self.server.base_url}/templates/template%2Fwith%3Fchars", f"{self.server.base_url}/templates/update%2Fwith%3Fchars", f"{self.server.base_url}/templates/delete%2Fwith%3Fchars", diff --git a/tests/test_client.py b/tests/test_client.py index 71fc628..4286f3c 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -79,31 +79,18 @@ def test_get_assembly(self, mock): self.assertEqual(response.data["assembly_id"], "abcdef12345") def test_assembly_urls_are_trusted_and_unauthenticated(self): - with mock.patch("transloadit.client.requests.request") as request_mock: + with mock.patch.object(self.transloadit.request, "public") as request_mock: for method in (self.transloadit.get_assembly, self.transloadit.cancel_assembly): with self.assertRaisesRegex(ValueError, "untrusted Assembly URL"): method(assembly_url="https://example.com/assemblies/abc123") request_mock.assert_not_called() - - raw_response = mock.Mock() - raw_response.json.return_value = {"ok": "ASSEMBLY_COMPLETED"} - with mock.patch( - "transloadit.client.requests.request", - return_value=raw_response, - ) as request_mock: self.transloadit.get_assembly( assembly_url="https://api2-region.transloadit.com/assemblies/abc123", params={"nonce": 123}, ) - - request_mock.assert_called_once() - method, url = request_mock.call_args.args - request_kwargs = request_mock.call_args.kwargs - self.assertEqual(method, "GET") - self.assertEqual(url, "https://api2-region.transloadit.com/assemblies/abc123") - self.assertEqual(request_kwargs["params"], {"nonce": 123}) - self.assertNotIn("Authorization", request_kwargs["headers"]) - self.assertFalse(request_kwargs["allow_redirects"]) + request_mock.assert_called_once_with( + "GET", "https://api2-region.transloadit.com/assemblies/abc123", params={"nonce": 123} + ) @requests_mock.Mocker() def test_issue_bearer_token_uses_basic_auth_and_form_encoding(self, requests_mock): diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py index 35561c8..ca5b32c 100644 --- a/tests/test_contract_endpoints.py +++ b/tests/test_contract_endpoints.py @@ -198,6 +198,107 @@ async def scenario(): asyncio.run(scenario()) +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_explicit_bearer_wins_over_netrc_for_every_http_method(mode, monkeypatch, tmp_path): + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.1 login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + async def scenario(): + async with wire_client(mode, bearer_token="selected-token") as (client, server): + await call(client, "list_auth_keys") + await call(client, "create_auth_key", {"description": "test"}) + await call(client, "update_auth_key", "key-id", {"description": "updated"}) + await call(client, "move_dam_asset", "asset-id", {"filename": "updated"}) + await call(client, "delete_auth_key", "key-id") + assert {request["method"] for request in server.requests} == {"GET", "POST", "PUT", "PATCH", "DELETE"} + assert all(request["headers"]["Authorization"] == "Bearer selected-token" for request in server.requests) + asyncio.run(scenario()) + + +def test_bearer_ignores_injected_session_account_credentials(): + async def scenario(): + async with wire_client("async") as (_, server): + async with aiohttp.ClientSession(auth=aiohttp.BasicAuth("ambient", "secret"), + headers={"Cookie": "ambient-cookie"}) as session: + client = AsyncTransloadit("key", None, service=server.url, session=session, bearer_token="selected-token") + await client.list_auth_keys() + assert server.requests[-1]["headers"]["Authorization"] == "Bearer selected-token" + assert "Cookie" not in server.requests[-1]["headers"] + assert not session.closed + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_assembly_capabilities_do_not_borrow_account_credentials(mode, monkeypatch, tmp_path): + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.1 login ambient password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + async def scenario(): + async with wire_client(mode, bearer_token="must-not-leak") as (client, server): + async with aiohttp.ClientSession(auth=aiohttp.BasicAuth("ambient", "secret"), + headers={"Cookie": "ambient-cookie"}) as session: + if mode == "async": + client = AsyncTransloadit("key", "secret", service=server.url, session=session, bearer_token="must-not-leak") + await call(client, "get_assembly", assembly_id=ASSEMBLY_ID) + await call(client, "cancel_assembly", assembly_url=server.url + "/assemblies/" + ASSEMBLY_ID) + assert len(server.requests) == 2 + for request in server.requests: + assert "Authorization" not in request["headers"] + assert "Cookie" not in request["headers"] + assert request["query"] == {} + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_text_mode_multipart_preserves_content_and_file_ownership(mode, tmp_path): + path = tmp_path / "text.txt" + path.write_text("caf\u00e9\n", encoding="utf-8") + async def scenario(): + async with wire_client(mode) as (client, server): + assembly = client.new_assembly() + with path.open(encoding="utf-8") as upload: + assembly.add_file(upload, "text") + if mode == "sync": + await asyncio.to_thread(assembly.create, resumable=False) + else: + await assembly.create(resumable=False) + assert not upload.closed + assert server.requests[-1]["fields"]["text"] == "caf\u00e9\n".encode() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_custom_service_can_poll_returned_worker_origin(mode): + async def scenario(): + async with wire_client(mode) as (client, server), wire_client(mode) as (_, worker): + server.assembly_response = {"ok": "ASSEMBLY_UPLOADING", "assembly_id": ASSEMBLY_ID, + "assembly_ssl_url": worker.url + "/assemblies/" + ASSEMBLY_ID} + assembly = client.new_assembly() + sleep_path = "transloadit.assembly.sleep" if mode == "sync" else "transloadit.async_assembly.asyncio.sleep" + with mock.patch(sleep_path, new_callable=mock.Mock if mode == "sync" else mock.AsyncMock): + if mode == "sync": + result = await asyncio.to_thread(assembly.create, wait=True) + else: + result = await assembly.create(wait=True) + assert result.data["ok"] == "ASSEMBLY_COMPLETED" + assert "Authorization" not in worker.requests[-1]["headers"] + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_polling_continues_through_replaying_assemblies(mode): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + make_mock = mock.Mock if mode == "sync" else mock.AsyncMock + completed = Response(data={"ok": "ASSEMBLY_COMPLETED"}, status_code=200) + client.get_assembly = make_mock(side_effect=[Response(data={"ok": "ASSEMBLY_REPLAYING"}, status_code=200), completed]) + sleep_path = "transloadit.client.sleep" if mode == "sync" else "transloadit.async_client.asyncio.sleep" + with mock.patch(sleep_path, new_callable=make_mock): + assert await call(client, "wait_for_assembly", "assembly") is completed + assert client.get_assembly.call_count == 2 + asyncio.run(scenario()) + + ASSEMBLY_ID = "a" * 32 @@ -222,6 +323,10 @@ async def handle(self, request): record = {"method": request.method, "path": request.path, "body": data, "fields": fields, "query": dict(request.query), "headers": CaseInsensitiveDict(request.headers)} self.requests.append(record) + if request.method == "GET" and request.path == "/assemblies/" + ASSEMBLY_ID: + return web.json_response({"ok": "ASSEMBLY_COMPLETED", "assembly_id": ASSEMBLY_ID}) + if request.method == "POST" and request.path == "/assemblies" and hasattr(self, "assembly_response"): + return web.json_response(self.assembly_response) if request.path == "/ws1": if self.stream_mode == "redirect": return web.Response(status=302, headers={"Location": self.url + "/redirect-target"}) diff --git a/transloadit/async_client.py b/transloadit/async_client.py index 02cd3fe..bd6b52a 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -98,27 +98,18 @@ async def _request_assembly_url(self, url, method, params=None): and candidate_hostname.startswith("api2-") and candidate_hostname.endswith(".transloadit.com") ) - if not (configured_origin or configured_https_host or api2_cell): + # Explicit custom/Gateway services retain their legacy worker origins. + # These are capability requests: session account credentials stay isolated. + custom_service = configured_hostname != "api2.transloadit.com" and not ( + configured_hostname.startswith("api2-") and configured_hostname.endswith(".transloadit.com") + ) + custom_destination = custom_service and not has_url_credentials and bool(candidate_hostname) and candidate.scheme in {"http", "https"} + if not (configured_origin or configured_https_host or api2_cell or custom_destination): raise ValueError("Refusing to request an untrusted Assembly URL.") if method not in {"GET", "DELETE"}: raise ValueError(f"Unsupported Assembly URL method: {method}") - session = await self.request._ensure_session() - async with session.request( - method, - candidate_url, - params=params, - headers=self.request._headers(), - timeout=self.request._timeout(), - allow_redirects=False, - ) as raw_response: - from .response import Response - - return Response( - data=await self.request._read_response_data(raw_response), - status_code=raw_response.status, - headers=raw_response.headers, - ) + return await self.request.public(method, candidate_url, params=params) async def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ @@ -639,7 +630,7 @@ async def wait_for_assembly(self, assembly_url: str, *, retries=3): return response # The polling is done if the assembly is not uploading or executing anymore. - if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING"): + if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING", "ASSEMBLY_REPLAYING"): return response await asyncio.sleep(1) diff --git a/transloadit/async_request.py b/transloadit/async_request.py index e35afc1..5a99ed9 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -89,6 +89,11 @@ def tell(self): return self._call("tell") +class _NonClosingTextUploadStream(_NonClosingUploadStream, io.TextIOBase): + # Preserve aiohttp's TextIOPayload selection and UTF-8 encoding of text reads. + pass + + class AsyncRequest: """ Transloadit tailored asynchronous HTTP request object. @@ -112,6 +117,22 @@ def _headers(self, url=None): headers["Authorization"] = "Bearer " + self.transloadit.bearer_token return headers + @asynccontextmanager + async def _api_session(self, url): + if "Authorization" in self._headers(url): + # Explicit bearer auth wins over netrc and injected account defaults. + async with self._isolated_session() as session: + yield session + else: + yield await self._ensure_session() + + def _request_options(self, url): + headers = self._headers(url) + options = {"headers": headers, "timeout": self._timeout(), "allow_redirects": False} + if "Authorization" in headers: + options.update(async_network_options(url)) + return options + def _get_session_lock(self): if self._session_lock is None: # Create the lock lazily so the client can be instantiated before the loop starts. @@ -172,13 +193,10 @@ async def get(self, path, params=None): Makes an asynchronous HTTP GET request. """ url = self._get_full_url(path) - session = await self._ensure_session() - async with session.get( + async with self._api_session(url) as session, session.get( url, params=self._to_request_payload(url, params), - headers=self._headers(url), - timeout=self._timeout(), - allow_redirects=False, + **self._request_options(url), ) as response: return Response( data=await self._read_response_data(response), @@ -194,7 +212,6 @@ async def post(self, path, data=None, extra_data=None, files=None): async def _form_request(self, method, path, data=None, extra_data=None, files=None): url = self._get_full_url(path) - session = await self._ensure_session() data = self._to_request_payload(url, data) or {} if extra_data: data.update(extra_data) @@ -206,7 +223,8 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No form.add_field(key, value) for key, file_stream in files.items(): - upload = _NonClosingUploadStream(file_stream) + wrapper = _NonClosingTextUploadStream if isinstance(file_stream, io.TextIOBase) else _NonClosingUploadStream + upload = wrapper(file_stream) uploads.append(upload) filename = get_upload_filename(file_stream, key) content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" @@ -221,12 +239,10 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No payload = self._normalize_payload(data) try: - async with getattr(session, method)( + async with self._api_session(url) as session, getattr(session, method)( url, data=payload, - headers=self._headers(url), - timeout=self._timeout(), - allow_redirects=False, + **self._request_options(url), ) as response: return Response( data=await self._read_response_data(response), @@ -256,14 +272,11 @@ async def delete(self, path, data=None): Makes an asynchronous HTTP DELETE request. """ url = self._get_full_url(path) - session = await self._ensure_session() data = self._normalize_payload(self._to_request_payload(url, data) or {}) - async with session.delete( + async with self._api_session(url) as session, session.delete( url, data=data, - headers=self._headers(url), - timeout=self._timeout(), - allow_redirects=False, + **self._request_options(url), ) as response: return Response( data=await self._read_response_data(response), diff --git a/transloadit/client.py b/transloadit/client.py index 2fb634e..5f7bbb1 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -108,22 +108,18 @@ def _request_assembly_url(self, url, method, params=None): and candidate_hostname.startswith("api2-") and candidate_hostname.endswith(".transloadit.com") ) - if not (configured_origin or configured_https_host or api2_cell): + # Explicit custom/Gateway services retain their legacy worker origins. + # These are capability requests: session account credentials stay isolated. + custom_service = configured_hostname != "api2.transloadit.com" and not ( + configured_hostname.startswith("api2-") and configured_hostname.endswith(".transloadit.com") + ) + custom_destination = custom_service and not has_url_credentials and bool(candidate_hostname) and candidate.scheme in {"http", "https"} + if not (configured_origin or configured_https_host or api2_cell or custom_destination): raise ValueError("Refusing to request an untrusted Assembly URL.") if method not in {"GET", "DELETE"}: raise ValueError(f"Unsupported Assembly URL method: {method}") - raw_response = requests.request( - method, - candidate_url, - params=params, - headers=request.Request.HEADERS, - timeout=request.TIMEOUT, - allow_redirects=False, - ) - from .response import Response - - return Response(raw_response) + return self.request.public(method, candidate_url, params=params) def create_assembly_with_id(self, assembly_id: str, data: Optional[dict] = None, extra_data: Optional[dict] = None, files: Optional[dict] = None): """ @@ -644,7 +640,7 @@ def wait_for_assembly(self, assembly_url: str, *, retries=3): return response # The polling is done if the assembly is not uploading or executing anymore. - if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING"): + if data.get("ok") not in ("ASSEMBLY_UPLOADING", "ASSEMBLY_EXECUTING", "ASSEMBLY_REPLAYING"): return response sleep(1) diff --git a/transloadit/request.py b/transloadit/request.py index c9b90a9..0f791a1 100644 --- a/transloadit/request.py +++ b/transloadit/request.py @@ -16,6 +16,12 @@ TIMEOUT = 60 +class _ExplicitAuthorization(requests.auth.AuthBase): + """Keep an explicit Authorization header from being replaced by netrc.""" + def __call__(self, request): + return request + + class Request: """ Transloadit tailored HTTP Request object. @@ -39,6 +45,9 @@ def _headers(self, url): headers["Authorization"] = "Bearer " + self.transloadit.bearer_token return headers + def _auth(self, url): + return _ExplicitAuthorization() if "Authorization" in self._headers(url) else None + @as_response def get(self, path, params=None): """ @@ -55,6 +64,7 @@ def get(self, path, params=None): url, params=self._to_request_payload(url, params), headers=self._headers(url), + auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False, ) @@ -85,6 +95,7 @@ def post(self, path, data=None, extra_data=None, files=None): data=data, files=files, headers=self._headers(url), + auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False, ) @@ -109,6 +120,7 @@ def put(self, path, data=None, extra_data=None, files=None): data=data, files=files, headers=self._headers(url), + auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False, ) @@ -117,7 +129,7 @@ def put(self, path, data=None, extra_data=None, files=None): def patch(self, path, data=None): url = self._get_full_url(path) return requests.patch(url, data=self._to_request_payload(url, data), - headers=self._headers(url), timeout=TIMEOUT, allow_redirects=False) + headers=self._headers(url), auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False) @as_response def delete(self, path, data=None): @@ -136,6 +148,7 @@ def delete(self, path, data=None): url, data=data, headers=self._headers(url), + auth=self._auth(url), timeout=TIMEOUT, allow_redirects=False, ) From 34d15b500d3a1b51cb135178737a430226cefd3c Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sat, 10 Oct 2026 23:54:09 +0200 Subject: [PATCH 59/64] Preserve async shutdown, proxy configuration and text upload lengths --- CHANGELOG.md | 3 +- README.md | 11 ++++-- docs/source/index.rst | 9 +++-- tests/test_api_url.py | 7 ++++ tests/test_async_client.py | 43 +++++++++------------ tests/test_contract_endpoints.py | 62 +++++++++++++++++++++++++++++-- tests/test_upload_cleanup.py | 53 ++++++++++++++++++++++++++ transloadit/api_url.py | 20 ++++++---- transloadit/async_assembly.py | 7 +--- transloadit/async_client.py | 15 +++++--- transloadit/async_request.py | 19 ++++++---- transloadit/client.py | 15 +++++--- transloadit/endpoint_transport.py | 9 ++++- transloadit/upload.py | 20 ++++++---- 14 files changed, 216 insertions(+), 77 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7bf3c94..472a733 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,9 +5,10 @@ * Added all 44 documented API operations to both sync and async clients: Assemblies, Assembly Notifications, Templates, Template Credentials, auth keys and token grants, DAM, statistics, Priority Job Slots, Billing, SSE and raw TUS. DAM operations marked alpha retain that status. The 16 separate-product storage/device/OAuth routes are tracked for 2.1 in #60. * Pinned the canonical API2 contract with producer revision and byte hash. Low-level methods and the coverage table regenerate deterministically; CI checks the committed bytes without API2 access. High-level Assembly, Template and upload helpers remain handwritten. * Added signed PATCH, multipart PUT Assembly replacement, optional bearer-token authentication and authorization-code/refresh-token issuance. SSE supports incremental events and context-managed cancellation/cleanup. Raw TUS preserves binary downloads and response headers, validates returned destinations and does not forward account credentials or follow redirects. -* Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run through `asyncio.to_thread()` so the event loop remains responsive instead of pretending the sync uploader is natively async. +* Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run in worker threads so the event loop remains responsive instead of pretending the sync uploader is natively async. * Async cancellation drains active multipart reads and resumable workers, including repeated cancellation, before releasing caller-owned files. Isolated public, token, SSE and raw TUS transports preserve proxy/TLS configuration without borrowing session or netrc account credentials. High-level TUS helpers validate metadata and preserve Assembly creation errors. * Explicit bearer authentication wins over ambient netrc or session auth. Assembly capability requests isolate account credentials while preserving custom deployment worker hosts. Async multipart uploads retain text-mode file support, and polling continues through `ASSEMBLY_REPLAYING`. +* Preserved legacy HTTP Assembly URLs by upgrading known API hosts to HTTPS, and aligned regional host checks with the pinned contract. Async transports retain explicit session proxy settings. Text uploads use chunked transfer when encoding/newline conversion changes their byte length; worker cleanup also survives global event-loop shutdown. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. diff --git a/README.md b/README.md index 4b796e5..8fb569d 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,7 @@ async def main(): asyncio.run(main()) ``` -The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded with `asyncio.to_thread()` so the event loop stays responsive. +The async client keeps polling on `asyncio.sleep`. Resumable uploads still use the existing TUS client, but are offloaded to worker threads so the event loop stays responsive. Cancellation of a resumable upload waits for the tuspy upload batch, including retries, to finish before releasing your files. Multipart cancellation waits for @@ -102,9 +102,10 @@ remain the default. To use a bearer token, pass authorization-code and refresh-token grants; omitted `grant_type` keeps the client-credentials default. Tokens are not refreshed automatically. -Public, token, SSE and raw TUS transports honor environment proxies. Sync calls also honor -`REQUESTS_CA_BUNDLE` / `CURL_CA_BUNDLE`; async transports reuse the DNS/TLS connector -of an injected aiohttp session. Public, token, SSE and raw TUS calls use isolated +Isolated transports preserve network configuration. Sync calls honor environment +proxies and `REQUESTS_CA_BUNDLE` / `CURL_CA_BUNDLE`; async calls retain an injected +aiohttp session's DNS/TLS connector, explicit proxy/auth and `trust_env` setting, +or use environment proxies by default. Public, token, SSE and raw TUS calls use isolated sessions so injected cookies, default account auth and netrc credentials cannot be forwarded accidentally. Explicit bearer authentication also takes precedence over netrc and injected session authentication. @@ -113,6 +114,8 @@ Assembly get/cancel requests use the same credential isolation. When `service` points to a custom deployment, its returned Assembly worker hosts remain supported, including for high-level polling. The default Transloadit service restricts these requests to its API hosts; neither mode follows redirects or accepts URL credentials. +Legacy HTTP `assembly_url` values on known Transloadit API hosts are upgraded to +HTTPS automatically. Both clients use the pinned contract's regional-host pattern. SSE uses the returned Assembly `update_stream_url` and a context manager: diff --git a/docs/source/index.rst b/docs/source/index.rst index f173c33..c29738f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -127,9 +127,10 @@ and ``files``. Requests are signed by default; pass ``bearer_token`` to use an existing token. ``issue_bearer_token`` also supports authorization-code and refresh flows. Automatic refresh is not performed. -Public, token, SSE and raw TUS transports honor environment proxies. Sync calls also honor -``REQUESTS_CA_BUNDLE`` / ``CURL_CA_BUNDLE``; async calls reuse an injected aiohttp -session's DNS/TLS connector. Public, token, SSE and raw TUS calls isolate cookies, +Isolated transports preserve network configuration. Sync calls honor environment +proxies and ``REQUESTS_CA_BUNDLE`` / ``CURL_CA_BUNDLE``; async calls retain an injected +session's DNS/TLS connector, explicit proxy/auth and ``trust_env`` setting, or use +environment proxies by default. Public, token, SSE and raw TUS calls isolate cookies, default account auth and netrc credentials. Explicit bearer authentication takes precedence over netrc and injected session authentication. @@ -137,6 +138,8 @@ Assembly get/cancel also isolate account credentials. Custom ``service`` deploym retain their returned Assembly worker hosts for high-level polling. The default Transloadit service restricts these requests to its API hosts; neither mode follows redirects or accepts credentials embedded in URLs. +Legacy HTTP ``assembly_url`` values on known Transloadit hosts are upgraded to HTTPS. +Both clients use the pinned contract's regional-host pattern. ``stream_assembly_status`` takes the returned ``update_stream_url`` and is used with ``with`` / ``async with``. Iterate its events with ``for`` / ``async for``; diff --git a/tests/test_api_url.py b/tests/test_api_url.py index 6ee85f2..e15862c 100644 --- a/tests/test_api_url.py +++ b/tests/test_api_url.py @@ -4,6 +4,13 @@ class ApiUrlTest(unittest.TestCase): + def test_regional_signing_follows_contract_hosts_and_https_port(self): + service = "https://api2.transloadit.com" + for host in ("api2-x.other.transloadit.com", "api2-xn--example.transloadit.com", "api2-morven.transloadit.com:8443"): + with self.subTest(host=host): + self.assertFalse(should_sign_api_url(f"https://{host}/auth_keys", service)) + self.assertTrue(should_sign_api_url("https://api2-morven.transloadit.com:443/auth_keys", service)) + def test_should_sign_same_service_url_with_different_host_casing(self): self.assertTrue( should_sign_api_url( diff --git a/tests/test_async_client.py b/tests/test_async_client.py index 01508f7..202ddc1 100644 --- a/tests/test_async_client.py +++ b/tests/test_async_client.py @@ -1075,13 +1075,12 @@ def upload(self_inner): new=mock.AsyncMock(side_effect=[rate_limited, success]), ) as post_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): - with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: - with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - response = await assembly.create(resumable=True, retries=2) + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True, retries=2) self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") self.assertEqual(post_mock.await_count, 2) - self.assertEqual(to_thread_mock.await_count, 1) + self.assertEqual(sum(entry[0] == "upload" for entry in calls), 1) self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1], ("uploader", {"assembly_url": f"{self.server.base_url}/assemblies/assembly-123", "fieldname": "file", "filename": "payload.bin"}, 2)) @@ -1136,13 +1135,12 @@ def uploader(self, **kwargs): new=mock.AsyncMock(side_effect=[rate_limited, success]), ) as post_mock: with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock): - with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: - with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - response = await assembly.create(resumable=True, retries=2) + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True, retries=2) self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") self.assertEqual(post_mock.await_count, 2) - self.assertEqual(to_thread_mock.await_count, 1) + self.assertEqual(sum(entry[0] == "upload" for entry in calls), 1) self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") @@ -1349,20 +1347,11 @@ def uploader(self, **kwargs): upload.name = 123 assembly.add_file(upload, "explicit_field") - with mock.patch( - "asyncio.to_thread", - new=mock.AsyncMock(side_effect=lambda func, *args: func(*args)), - ) as to_thread_mock: - with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - response = await assembly.create(resumable=True) + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + response = await assembly.create(resumable=True) self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") - tus_upload_calls = [ - call - for call in to_thread_mock.await_args_list - if getattr(call.args[0], "__name__", "") == "_do_tus_upload" - ] - self.assertEqual(len(tus_upload_calls), 1) + self.assertEqual(sum(entry[0] == "upload" for entry in calls), 1) create_request = next( entry for entry in self.server.requests if entry["path"] == "/assemblies" and entry["method"] == "POST" @@ -1815,14 +1804,16 @@ async def test_async_request_uses_filename_fallback_for_trailing_slash_stream_na self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED") self.assertEqual(session.calls[0][1]["data"]._fields[2][0]["filename"], "file") - async def test_async_resumable_upload_uses_to_thread(self): + async def test_async_resumable_upload_runs_in_worker_thread(self): calls = [] + worker_threads = [] class _Uploader: def __init__(self, metadata): self.metadata = metadata def upload(self): + worker_threads.append(threading.get_ident()) calls.append(("upload", dict(self.metadata))) class _TusClient: @@ -1847,13 +1838,13 @@ def uploader(self, **kwargs): ) with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)): - with mock.patch("asyncio.to_thread", new=mock.AsyncMock(side_effect=lambda func, *args: func(*args))) as to_thread_mock: - with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): - assembly.add_file(io.BytesIO(b"payload")) - response = await assembly.create(resumable=True, retries=5) + with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient): + assembly.add_file(io.BytesIO(b"payload")) + response = await assembly.create(resumable=True, retries=5) self.assertEqual(response.data["assembly_ssl_url"], f"{self.server.base_url}/assemblies/assembly-123") - to_thread_mock.assert_awaited_once() + self.assertEqual(len(worker_threads), 1) + self.assertNotEqual(worker_threads[0], threading.get_ident()) self.assertEqual(calls[0], ("client", f"{self.server.base_url}/uploads")) self.assertEqual(calls[1][0], "uploader") metadata = calls[1][1] diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py index ca5b32c..fbc30fd 100644 --- a/tests/test_contract_endpoints.py +++ b/tests/test_contract_endpoints.py @@ -250,13 +250,16 @@ async def scenario(): @pytest.mark.parametrize("mode", ["sync", "async"]) -def test_text_mode_multipart_preserves_content_and_file_ownership(mode, tmp_path): +@pytest.mark.parametrize("encoding,line_ending", [("utf-8", "\n"), ("utf-8", "\r\n"), ("utf-16", "\n")]) +def test_text_mode_multipart_preserves_content_and_file_ownership(mode, tmp_path, encoding, line_ending): path = tmp_path / "text.txt" - path.write_text("caf\u00e9\n", encoding="utf-8") + path.write_bytes(("caf\u00e9" + line_ending).encode(encoding)) async def scenario(): async with wire_client(mode) as (client, server): + if mode == "async": + client.request._timeout = lambda: aiohttp.ClientTimeout(total=5) assembly = client.new_assembly() - with path.open(encoding="utf-8") as upload: + with path.open(encoding=encoding) as upload: assembly.add_file(upload, "text") if mode == "sync": await asyncio.to_thread(assembly.create, resumable=False) @@ -299,6 +302,59 @@ async def scenario(): asyncio.run(scenario()) +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("host", ["api2.transloadit.com", "api2-morven.transloadit.com"]) +def test_legacy_http_assembly_urls_use_https(mode, host): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() + for method, verb in [("get_assembly", "GET"), ("cancel_assembly", "DELETE")]: + await call(client, method, assembly_url=f"http://{host}/assemblies/{ASSEMBLY_ID}") + client.request.public.assert_called_with(verb, f"https://{host}/assemblies/{ASSEMBLY_ID}", params=None) + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("host", ["api2-x.other.transloadit.com", "api2-xn--example.transloadit.com"]) +def test_assembly_urls_use_contract_host_pattern(mode, host): + async def scenario(): + client = (Transloadit if mode == "sync" else AsyncTransloadit)("key", "secret") + client.request.public = (mock.Mock if mode == "sync" else mock.AsyncMock)() + with pytest.raises(ValueError, match="untrusted Assembly URL"): + await call(client, "get_assembly", assembly_url=f"https://{host}/assemblies/{ASSEMBLY_ID}") + client.request.public.assert_not_called() + asyncio.run(scenario()) + + +@pytest.mark.parametrize("trust_env", [False, True]) +def test_isolated_async_calls_preserve_explicit_proxy_configuration(monkeypatch, trust_env): + # The injected proxy takes precedence over an unusable environment proxy. + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.3:1") + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (_, server): + proxy_auth = aiohttp.BasicAuth("proxy-user", "proxy-password") + async with aiohttp.ClientSession(proxy=server.url, proxy_auth=proxy_auth, trust_env=trust_env) as session: + service = "http://127.0.0.2:1" + client = AsyncTransloadit("key", "secret", service=service, session=session, bearer_token="selected-token") + await client.list_auth_keys() + await client.get_assembly(assembly_id=ASSEMBLY_ID) + await client.list_assembly_notifications(ASSEMBLY_ID) + await client.issue_bearer_token({"grant_type": "refresh_token", "refresh_token": "refresh"}) + await client.tus_options({"assembly_id": ASSEMBLY_ID, "assembly_ssl_url": service + "/assemblies/" + ASSEMBLY_ID, + "tus_url": service + "/resumable/files"}) + async with client.stream_assembly_status(service + "/ws1?assembly=" + ASSEMBLY_ID) as events: + assert [event async for event in events][-1].terminal + assert not session.closed + assert len(server.requests) == 6 + assert all(request["headers"]["Proxy-Authorization"] == proxy_auth.encode() for request in server.requests) + assert server.requests[0]["headers"]["Authorization"] == "Bearer selected-token" + assert all("Authorization" not in request["headers"] for request in server.requests[1:]) + asyncio.run(scenario()) + + ASSEMBLY_ID = "a" * 32 diff --git a/tests/test_upload_cleanup.py b/tests/test_upload_cleanup.py index dc52066..8ebf2ae 100644 --- a/tests/test_upload_cleanup.py +++ b/tests/test_upload_cleanup.py @@ -76,3 +76,56 @@ def upload(*args): await task assert await asyncio.to_thread(finished.wait, 5) asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["tus", "multipart"]) +def test_global_event_loop_shutdown_keeps_files_open_until_workers_finish(mode): + started, release = threading.Event(), threading.Event() + errors = [] + class Stream(io.BytesIO): + def read(self, *args): + started.set() + release.wait(5) + try: + return super().read(*args) + except ValueError as error: + errors.append(str(error)) + raise + class Writer: + async def write(self, chunk): + pass + class Context: + def __init__(self, data): + self.payload = data() + async def __aenter__(self): + await self.payload.write(Writer()) + raise AssertionError("Expected cancellation") + async def __aexit__(self, *args): + await self.payload.close() + class Session: + closed = False + def post(self, url, **kwargs): + return Context(kwargs["data"]) + stream = Stream(b"payload") + async def main(): + client = AsyncTransloadit("key", "secret", session=Session()) + assembly = client.new_assembly() + assembly._do_tus_upload = lambda *args: stream.read() + async def upload(): + with stream: + if mode == "tus": + await assembly._do_tus_upload_async("assembly", "upload", 3) + else: + await client.create_assembly(files={"file": stream}) + task = asyncio.create_task(upload()) + assert await asyncio.to_thread(started.wait, 5) + task.cancel() + await asyncio.sleep(.02) # Enter cleanup before asyncio.run cancels all remaining tasks. + asyncio.get_running_loop().call_later(.05, release.set) + # Returning triggers real asyncio.run shutdown, including child-task cancellation. + try: + asyncio.run(main()) + finally: + release.set() + assert stream.closed + assert errors == [], "A worker read the caller's file after loop shutdown closed it" diff --git a/transloadit/api_url.py b/transloadit/api_url.py index f952a76..48edcce 100644 --- a/transloadit/api_url.py +++ b/transloadit/api_url.py @@ -1,5 +1,13 @@ +import re from urllib.parse import urlparse +from ._contract import CONTRACT + + +def is_transloadit_api_host(hostname): + hostname = (hostname or "").lower() + return hostname == "api2.transloadit.com" or re.fullmatch(CONTRACT["capability"]["publicHostPattern"], hostname) is not None + def normalize_service_url(service): if not isinstance(service, str): @@ -42,16 +50,14 @@ def should_sign_api_url(url, service): return True service_hostname = (parsed_service.hostname or "").lower() - service_is_transloadit_api = service_hostname == "api2.transloadit.com" or ( - service_hostname.startswith("api2-") - and service_hostname.endswith(".transloadit.com") - ) + service_is_transloadit_api = is_transloadit_api_host(service_hostname) hostname = (parsed_url.hostname or "").lower() - url_is_transloadit_api = hostname == "api2.transloadit.com" or ( - hostname.startswith("api2-") and hostname.endswith(".transloadit.com") - ) + url_is_transloadit_api = is_transloadit_api_host(hostname) return ( service_is_transloadit_api and parsed_url.scheme == "https" + and parsed_url.port in {None, 443} + and parsed_url.username is None + and parsed_url.password is None and url_is_transloadit_api ) diff --git a/transloadit/async_assembly.py b/transloadit/async_assembly.py index 497de83..e2f4c20 100644 --- a/transloadit/async_assembly.py +++ b/transloadit/async_assembly.py @@ -4,7 +4,7 @@ from tusclient import client as tus from . import optionbuilder -from .upload import get_upload_filename, wait_for_upload_worker +from .upload import get_upload_filename, run_upload_worker class AsyncAssembly(optionbuilder.OptionBuilder): @@ -84,10 +84,7 @@ async def _do_tus_upload_async(self, assembly_url, tus_url, retries): # tuspy is synchronous, so cancellation cannot abort an upload already running in # the worker thread. Wait for the worker to release file streams before letting # cancellation unwind caller-owned file context managers. - upload_task = asyncio.create_task( - asyncio.to_thread(self._do_tus_upload, assembly_url, tus_url, retries) - ) - await wait_for_upload_worker(upload_task) + await run_upload_worker(self._do_tus_upload, assembly_url, tus_url, retries) async def create(self, wait=False, resumable=True, retries=3): """ diff --git a/transloadit/async_client.py b/transloadit/async_client.py index bd6b52a..9a9bc26 100644 --- a/transloadit/async_client.py +++ b/transloadit/async_client.py @@ -3,7 +3,7 @@ from urllib.parse import quote from . import async_assembly, async_request, async_template -from .api_url import normalize_service_url, require_path_id +from .api_url import is_transloadit_api_host, normalize_service_url, require_path_id from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url @@ -69,6 +69,12 @@ async def _request_assembly_url(self, url, method, params=None): ) try: candidate = urlparse(candidate_url) + if (candidate.scheme == "http" and candidate.port in {None, 80} + and candidate.username is None and candidate.password is None + and is_transloadit_api_host(candidate.hostname)): + # Preserve the API's legacy assembly_url field without plain HTTP. + candidate = candidate._replace(scheme="https", netloc=candidate.hostname) + candidate_url = candidate.geturl() configured = urlparse(self.service) candidate_port = candidate.port or (443 if candidate.scheme == "https" else 80) configured_port = configured.port or (443 if configured.scheme == "https" else 80) @@ -95,14 +101,11 @@ async def _request_assembly_url(self, url, method, params=None): not has_url_credentials and candidate.scheme == "https" and candidate_port == 443 - and candidate_hostname.startswith("api2-") - and candidate_hostname.endswith(".transloadit.com") + and is_transloadit_api_host(candidate_hostname) ) # Explicit custom/Gateway services retain their legacy worker origins. # These are capability requests: session account credentials stay isolated. - custom_service = configured_hostname != "api2.transloadit.com" and not ( - configured_hostname.startswith("api2-") and configured_hostname.endswith(".transloadit.com") - ) + custom_service = not is_transloadit_api_host(configured_hostname) custom_destination = custom_service and not has_url_credentials and bool(candidate_hostname) and candidate.scheme in {"http", "https"} if not (configured_origin or configured_https_host or api2_cell or custom_destination): raise ValueError("Refusing to request an untrusted Assembly URL.") diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 5a99ed9..824c2f7 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -19,7 +19,7 @@ from .endpoint_transport import async_network_options, capability_url, token_request, tus_request, validate_upload_location from .response import Response from .stream import EventParser, StreamError -from .upload import get_upload_filename, wait_for_upload_worker +from .upload import get_upload_filename, run_upload_worker TIMEOUT = 60 @@ -91,7 +91,10 @@ def tell(self): class _NonClosingTextUploadStream(_NonClosingUploadStream, io.TextIOBase): # Preserve aiohttp's TextIOPayload selection and UTF-8 encoding of text reads. - pass + def fileno(self): + # Disk byte size is not the encoded payload length (CRLF, UTF-16, etc.). + # Unknown length makes aiohttp use chunked transfer without buffering. + raise io.UnsupportedOperation("Text upload byte length is unknown.") class AsyncRequest: @@ -130,7 +133,7 @@ def _request_options(self, url): headers = self._headers(url) options = {"headers": headers, "timeout": self._timeout(), "allow_redirects": False} if "Authorization" in headers: - options.update(async_network_options(url)) + options.update(async_network_options(url, self._session)) return options def _get_session_lock(self): @@ -256,7 +259,7 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No def drain(): for upload in uploads: upload.drain() - await wait_for_upload_worker(asyncio.create_task(asyncio.to_thread(drain))) + await run_upload_worker(drain) async def put(self, path, data=None, extra_data=None, files=None): """ @@ -333,7 +336,7 @@ async def public(self, method, path, params=None, data=None): async with self._isolated_session() as session: async with session.request(method, url, params=params, data=data, headers=self._headers(), timeout=self._timeout(), allow_redirects=False, - **async_network_options(url)) as response: + **async_network_options(url, self._session)) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) @@ -342,7 +345,7 @@ async def issue_bearer_token(self, data=None): headers.update(self._headers()) async with self._isolated_session() as session: async with session.post(url, data=self._normalize_payload(data), headers=headers, - timeout=self._timeout(), allow_redirects=False, **async_network_options(url)) as response: + timeout=self._timeout(), allow_redirects=False, **async_network_options(url, self._session)) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) @@ -351,7 +354,7 @@ async def tus(self, operation_id, location, headers=None, body=None): headers.update(self._headers()) async with self._isolated_session() as session: async with session.request(spec["method"], url, data=body, headers=headers, - timeout=self._timeout(), allow_redirects=False, **async_network_options(url)) as raw: + timeout=self._timeout(), allow_redirects=False, **async_network_options(url, self._session)) as raw: data = await raw.read() if spec["binary_response"] else await self._read_response_data(raw) response = Response(data=data, status_code=raw.status, headers=CaseInsensitiveDict(raw.headers)) if spec["method"] == "POST": @@ -365,7 +368,7 @@ async def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): timeout = aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=read_timeout) async with self._isolated_session() as session: async with session.get(url, headers={**self._headers(), "Accept": "text/event-stream"}, - timeout=timeout, allow_redirects=False, **async_network_options(url)) as response: + timeout=timeout, allow_redirects=False, **async_network_options(url, self._session)) as response: if response.status != 200: raise StreamError(response.status) if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": diff --git a/transloadit/client.py b/transloadit/client.py index 5f7bbb1..e5c22d2 100644 --- a/transloadit/client.py +++ b/transloadit/client.py @@ -6,7 +6,7 @@ import requests from . import assembly, request, template -from .api_url import normalize_service_url, require_path_id +from .api_url import is_transloadit_api_host, normalize_service_url, require_path_id from .upload import check_assembly_created, encode_upload_metadata from .smart_cdn import URL_PARAM_VALUES, build_signed_smart_cdn_url @@ -79,6 +79,12 @@ def _request_assembly_url(self, url, method, params=None): ) try: candidate = urlparse(candidate_url) + if (candidate.scheme == "http" and candidate.port in {None, 80} + and candidate.username is None and candidate.password is None + and is_transloadit_api_host(candidate.hostname)): + # Preserve the API's legacy assembly_url field without plain HTTP. + candidate = candidate._replace(scheme="https", netloc=candidate.hostname) + candidate_url = candidate.geturl() configured = urlparse(self.service) candidate_port = candidate.port or (443 if candidate.scheme == "https" else 80) configured_port = configured.port or (443 if configured.scheme == "https" else 80) @@ -105,14 +111,11 @@ def _request_assembly_url(self, url, method, params=None): not has_url_credentials and candidate.scheme == "https" and candidate_port == 443 - and candidate_hostname.startswith("api2-") - and candidate_hostname.endswith(".transloadit.com") + and is_transloadit_api_host(candidate_hostname) ) # Explicit custom/Gateway services retain their legacy worker origins. # These are capability requests: session account credentials stay isolated. - custom_service = configured_hostname != "api2.transloadit.com" and not ( - configured_hostname.startswith("api2-") and configured_hostname.endswith(".transloadit.com") - ) + custom_service = not is_transloadit_api_host(configured_hostname) custom_destination = custom_service and not has_url_credentials and bool(candidate_hostname) and candidate.scheme in {"http", "https"} if not (configured_origin or configured_https_host or api2_cell or custom_destination): raise ValueError("Refusing to request an untrusted Assembly URL.") diff --git a/transloadit/endpoint_transport.py b/transloadit/endpoint_transport.py index ca736e0..a4354dd 100644 --- a/transloadit/endpoint_transport.py +++ b/transloadit/endpoint_transport.py @@ -19,7 +19,14 @@ def sync_network_options(url): "verify": os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("CURL_CA_BUNDLE") or True} -def async_network_options(url): +def async_network_options(url, session=None): + # aiohttp exposes the connector publicly, but its session-level proxy defaults + # only through these attributes. Keep explicit proxy/auth ahead of environment. + proxy = getattr(session, "_default_proxy", None) + if proxy is not None: + return {"proxy": proxy, "proxy_auth": getattr(session, "_default_proxy_auth", None)} + if session is not None and not getattr(session, "trust_env", True): + return {"proxy": None} proxies = get_environ_proxies(url) return {"proxy": proxies.get(urlsplit(url).scheme) or proxies.get("all")} diff --git a/transloadit/upload.py b/transloadit/upload.py index e647835..0f5de29 100644 --- a/transloadit/upload.py +++ b/transloadit/upload.py @@ -1,24 +1,30 @@ import asyncio import base64 +import contextvars +from functools import partial import os import re -async def wait_for_upload_worker(task): - """Drain an owned worker even when the caller is cancelled more than once.""" +async def run_upload_worker(function, *args): + """Run and drain a worker, including during global event-loop shutdown.""" + context = contextvars.copy_context() + # Executor futures are not Tasks cancelled by asyncio.run's global shutdown. + # Shielding this private future therefore tracks actual thread completion. + future = asyncio.get_running_loop().run_in_executor(None, partial(context.run, function, *args)) cancelled = False - while not task.done(): + while not future.done(): try: - await asyncio.shield(task) + await asyncio.shield(future) except asyncio.CancelledError: cancelled = True except Exception: break if cancelled: - if not task.cancelled(): - task.exception() # Retrieve a worker failure while preserving cancellation. + if not future.cancelled(): + future.exception() # Retrieve a worker failure while preserving cancellation. raise asyncio.CancelledError - return task.result() + return future.result() def encode_upload_metadata(fieldname, filename, user_meta): From 456047b06088c1c6b456da38f2dd301dffe6004a Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 11 Oct 2026 00:04:27 +0200 Subject: [PATCH 60/64] Match async proxy policy and preserve multipart filenames --- CHANGELOG.md | 1 + tests/test_contract_endpoints.py | 67 ++++++++++++++++++++++++++++++- transloadit/async_request.py | 32 +++++++++------ transloadit/endpoint_transport.py | 14 +++++-- 4 files changed, 97 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 472a733..49b5d67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ * Async cancellation drains active multipart reads and resumable workers, including repeated cancellation, before releasing caller-owned files. Isolated public, token, SSE and raw TUS transports preserve proxy/TLS configuration without borrowing session or netrc account credentials. High-level TUS helpers validate metadata and preserve Assembly creation errors. * Explicit bearer authentication wins over ambient netrc or session auth. Assembly capability requests isolate account credentials while preserving custom deployment worker hosts. Async multipart uploads retain text-mode file support, and polling continues through `ASSEMBLY_REPLAYING`. * Preserved legacy HTTP Assembly URLs by upgrading known API hosts to HTTPS, and aligned regional host checks with the pinned contract. Async transports retain explicit session proxy settings. Text uploads use chunked transfer when encoding/newline conversion changes their byte length; worker cleanup also survives global event-loop shutdown. +* Async multipart requests preserve spaces and Unicode in filenames with safe header quoting. Isolated async calls use aiohttp's environment proxy policy, including proxy-only netrc authentication. * Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. * Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. * Fixed sync and async template creation to send the current API `template` payload shape. diff --git a/tests/test_contract_endpoints.py b/tests/test_contract_endpoints.py index fbc30fd..e55a887 100644 --- a/tests/test_contract_endpoints.py +++ b/tests/test_contract_endpoints.py @@ -355,6 +355,68 @@ async def scenario(): asyncio.run(scenario()) +def test_async_proxy_selection_matches_signed_calls_with_all_proxy(monkeypatch): + for name in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY", "all_proxy", "no_proxy"): + monkeypatch.delenv(name, raising=False) + monkeypatch.setenv("ALL_PROXY", "socks5://127.0.0.2:1") + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (client, server): + await client.list_templates() + await client.get_assembly(assembly_id=ASSEMBLY_ID) + client.bearer_token = "selected-token" + await client.list_templates() + assert len(server.requests) == 3 + asyncio.run(scenario()) + + +def test_async_environment_proxy_preserves_proxy_netrc_only(monkeypatch, tmp_path): + netrc = tmp_path / "netrc" + netrc.write_text("machine 127.0.0.1 login proxy-user password proxy-password\nmachine 127.0.0.2 login origin-user password must-not-leak\n") + monkeypatch.setenv("NETRC", str(netrc)) + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.delenv("no_proxy", raising=False) + monkeypatch.setenv("NO_PROXY", "") + async def scenario(): + async with wire_client("async") as (client, server): + monkeypatch.setenv("HTTP_PROXY", server.url) + client.service = "http://127.0.0.2:1" + await client.get_assembly(assembly_id=ASSEMBLY_ID) + client.bearer_token = "selected-token" + await client.list_templates() + for request in server.requests: + assert request["headers"]["Proxy-Authorization"] == aiohttp.BasicAuth("proxy-user", "proxy-password").encode() + assert "Authorization" not in server.requests[0]["headers"] + assert server.requests[1]["headers"]["Authorization"] == "Bearer selected-token" + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +@pytest.mark.parametrize("filename", ["my photo.jpg", "caf\u00e9.jpg", "quote\"name.txt", "newline\r\nname.txt"]) +def test_multipart_preserves_original_filename(mode, filename): + async def scenario(): + async with wire_client(mode) as (client, server): + upload = io.BytesIO(b"data") + upload.name = filename + await call(client, "create_assembly", files={"file": upload}) + # Quoting must prevent header injection while preserving spaces/UTF-8. + expected = filename.replace("\r", "%0D").replace("\n", "%0A").replace('"', '%22') + assert server.requests[-1]["filenames"]["file"] == expected + assert not upload.closed + asyncio.run(scenario()) + + +@pytest.mark.parametrize("mode", ["sync", "async"]) +def test_multipart_field_names_cannot_inject_headers(mode): + async def scenario(): + async with wire_client(mode) as (client, server): + await call(client, "create_assembly", files={"file\r\nname": io.BytesIO(b"data")}, + extra_data={"quoted\"field": "value"}) + assert server.requests[-1]["fields"]["file%0D%0Aname"] == b"data" + assert server.requests[-1]["fields"]["quoted%22field"] == "value" + asyncio.run(scenario()) + + ASSEMBLY_ID = "a" * 32 @@ -369,14 +431,17 @@ def __init__(self): async def handle(self, request): data = b"" fields = {} + filenames = {} if request.content_type == "multipart/form-data": for key, value in (await request.post()).items(): fields[key] = value.file.read() if isinstance(value, web.FileField) else value + if isinstance(value, web.FileField): + filenames[key] = value.filename else: data = await request.read() if request.content_type == "application/x-www-form-urlencoded": fields = {key: values[0] for key, values in parse_qs(data.decode()).items()} - record = {"method": request.method, "path": request.path, "body": data, + record = {"method": request.method, "path": request.path, "body": data, "filenames": filenames, "fields": fields, "query": dict(request.query), "headers": CaseInsensitiveDict(request.headers)} self.requests.append(record) if request.method == "GET" and request.path == "/assemblies/" + ASSEMBLY_ID: diff --git a/transloadit/async_request.py b/transloadit/async_request.py index 824c2f7..cd4f5e9 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -24,6 +24,10 @@ TIMEOUT = 60 +def _multipart_parameter(value): + return str(value).replace("\r", "%0D").replace("\n", "%0A").replace('"', "%22") + + class _NonClosingUploadStream(io.IOBase): def __init__(self, file_stream): self._file_stream = file_stream @@ -129,11 +133,11 @@ async def _api_session(self, url): else: yield await self._ensure_session() - def _request_options(self, url): + async def _request_options(self, url): headers = self._headers(url) options = {"headers": headers, "timeout": self._timeout(), "allow_redirects": False} if "Authorization" in headers: - options.update(async_network_options(url, self._session)) + options.update(await async_network_options(url, self._session)) return options def _get_session_lock(self): @@ -199,7 +203,7 @@ async def get(self, path, params=None): async with self._api_session(url) as session, session.get( url, params=self._to_request_payload(url, params), - **self._request_options(url), + **(await self._request_options(url)), ) as response: return Response( data=await self._read_response_data(response), @@ -221,9 +225,11 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No uploads = [] if files: - form = aiohttp.FormData() + # API2 preserves percent escapes in filename parameters. Match + # Requests' RFC 7578 quoting while retaining spaces and UTF-8. + form = aiohttp.FormData(quote_fields=False) for key, value in self._normalize_payload(data): - form.add_field(key, value) + form.add_field(_multipart_parameter(key), value) for key, file_stream in files.items(): wrapper = _NonClosingTextUploadStream if isinstance(file_stream, io.TextIOBase) else _NonClosingUploadStream @@ -232,9 +238,9 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No filename = get_upload_filename(file_stream, key) content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream" form.add_field( - key, + _multipart_parameter(key), upload, - filename=filename, + filename=_multipart_parameter(filename), content_type=content_type, ) payload = form @@ -245,7 +251,7 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No async with self._api_session(url) as session, getattr(session, method)( url, data=payload, - **self._request_options(url), + **(await self._request_options(url)), ) as response: return Response( data=await self._read_response_data(response), @@ -279,7 +285,7 @@ async def delete(self, path, data=None): async with self._api_session(url) as session, session.delete( url, data=data, - **self._request_options(url), + **(await self._request_options(url)), ) as response: return Response( data=await self._read_response_data(response), @@ -336,7 +342,7 @@ async def public(self, method, path, params=None, data=None): async with self._isolated_session() as session: async with session.request(method, url, params=params, data=data, headers=self._headers(), timeout=self._timeout(), allow_redirects=False, - **async_network_options(url, self._session)) as response: + **(await async_network_options(url, self._session))) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) @@ -345,7 +351,7 @@ async def issue_bearer_token(self, data=None): headers.update(self._headers()) async with self._isolated_session() as session: async with session.post(url, data=self._normalize_payload(data), headers=headers, - timeout=self._timeout(), allow_redirects=False, **async_network_options(url, self._session)) as response: + timeout=self._timeout(), allow_redirects=False, **(await async_network_options(url, self._session))) as response: return Response(data=await self._read_response_data(response), status_code=response.status, headers=CaseInsensitiveDict(response.headers)) @@ -354,7 +360,7 @@ async def tus(self, operation_id, location, headers=None, body=None): headers.update(self._headers()) async with self._isolated_session() as session: async with session.request(spec["method"], url, data=body, headers=headers, - timeout=self._timeout(), allow_redirects=False, **async_network_options(url, self._session)) as raw: + timeout=self._timeout(), allow_redirects=False, **(await async_network_options(url, self._session))) as raw: data = await raw.read() if spec["binary_response"] else await self._read_response_data(raw) response = Response(data=data, status_code=raw.status, headers=CaseInsensitiveDict(raw.headers)) if spec["method"] == "POST": @@ -368,7 +374,7 @@ async def stream_status(self, url, *, read_timeout=120, max_event_size=1048576): timeout = aiohttp.ClientTimeout(total=None, sock_connect=TIMEOUT, sock_read=read_timeout) async with self._isolated_session() as session: async with session.get(url, headers={**self._headers(), "Accept": "text/event-stream"}, - timeout=timeout, allow_redirects=False, **async_network_options(url, self._session)) as response: + timeout=timeout, allow_redirects=False, **(await async_network_options(url, self._session))) as response: if response.status != 200: raise StreamError(response.status) if response.headers.get("Content-Type", "").split(";", 1)[0].lower() != "text/event-stream": diff --git a/transloadit/endpoint_transport.py b/transloadit/endpoint_transport.py index a4354dd..4bafc20 100644 --- a/transloadit/endpoint_transport.py +++ b/transloadit/endpoint_transport.py @@ -1,5 +1,6 @@ """Shared wire preparation for OAuth, SSE and raw TUS endpoints.""" import base64 +import asyncio import copy import os from ipaddress import ip_address @@ -8,6 +9,8 @@ from requests.structures import CaseInsensitiveDict from requests.utils import get_environ_proxies +from aiohttp.helpers import get_env_proxy_for_url +from yarl import URL from ._contract import CONTRACT from .response import Response @@ -19,7 +22,7 @@ def sync_network_options(url): "verify": os.environ.get("REQUESTS_CA_BUNDLE") or os.environ.get("CURL_CA_BUNDLE") or True} -def async_network_options(url, session=None): +async def async_network_options(url, session=None): # aiohttp exposes the connector publicly, but its session-level proxy defaults # only through these attributes. Keep explicit proxy/auth ahead of environment. proxy = getattr(session, "_default_proxy", None) @@ -27,8 +30,13 @@ def async_network_options(url, session=None): return {"proxy": proxy, "proxy_auth": getattr(session, "_default_proxy_auth", None)} if session is not None and not getattr(session, "trust_env", True): return {"proxy": None} - proxies = get_environ_proxies(url) - return {"proxy": proxies.get(urlsplit(url).scheme) or proxies.get("all")} + try: + # Use aiohttp's exact policy (including proxy-only netrc credentials), + # and keep netrc file reads off the event loop like ClientSession does. + proxy, proxy_auth = await asyncio.to_thread(get_env_proxy_for_url, URL(url)) + except LookupError: + return {"proxy": None} + return {"proxy": proxy, "proxy_auth": proxy_auth} def token_request(client, data): From 8faf5700a5c5f371e649a16e928b71fb9eb79c11 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 11 Oct 2026 00:10:50 +0200 Subject: [PATCH 61/64] Clarify multipart quoting compatibility after final review --- transloadit/async_request.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/transloadit/async_request.py b/transloadit/async_request.py index cd4f5e9..ec83d65 100644 --- a/transloadit/async_request.py +++ b/transloadit/async_request.py @@ -225,8 +225,8 @@ async def _form_request(self, method, path, data=None, extra_data=None, files=No uploads = [] if files: - # API2 preserves percent escapes in filename parameters. Match - # Requests' RFC 7578 quoting while retaining spaces and UTF-8. + # Retain spaces/UTF-8; escape CR/LF/quotes as Requests does. aiohttp + # additionally escapes backslashes, which API2 decodes equivalently. form = aiohttp.FormData(quote_fields=False) for key, value in self._normalize_payload(data): form.add_field(_multipart_parameter(key), value) From a63d7d42d877b50031a7ec7941989bf461e9a895 Mon Sep 17 00:00:00 2001 From: Kevin van Zonneveld Date: Sun, 11 Oct 2026 19:38:18 +0200 Subject: [PATCH 62/64] Keep Python 2.0 on handwritten async client surface --- .gitattributes | 8 +- .github/workflows/ci.yml | 5 +- CHANGELOG.md | 23 +- README.md | 72 +- contracts/api2-contract.json.gz | Bin 1012247 -> 0 bytes contracts/api2-contract.lock.json | 6 - docs/api-coverage.md | 111 --- docs/source/index.rst | 60 +- examples/README.md | 7 - .../api2-devdock-assembly-lifecycle/main.py | 173 ---- .../api2-devdock-template-lifecycle/main.py | 196 ----- examples/api2-devdock-tus-assembly/main.py | 131 --- .../api2-devdock-tus-resume-upload/main.py | 203 ----- examples/assembly_with_template.py | 6 +- examples/async_image_resize.py | 4 +- examples/async_template_lifecycle.py | 4 +- examples/file_to_tts.py | 2 +- examples/image_resize.py | 4 +- examples/resumable_upload.py | 4 +- examples/template_lifecycle.py | 4 +- examples/video_translator.py | 2 +- pyproject.toml | 5 - scripts/generate_endpoints.py | 219 ----- tests/test_api_url.py | 2 +- tests/test_async_client.py | 205 +---- tests/test_client.py | 195 +---- tests/test_contract_endpoints.py | 803 ------------------ tests/test_e2e_endpoints.py | 85 -- tests/test_e2e_upload.py | 21 +- tests/test_examples.py | 63 +- tests/test_template.py | 4 +- tests/test_transport.py | 304 +++++++ tests/test_upload_cleanup.py | 8 +- tox.ini | 1 - transloadit/_contract.py | 285 ------- transloadit/api_url.py | 4 +- transloadit/assembly.py | 3 +- transloadit/async_assembly.py | 3 +- transloadit/async_client.py | 551 ++---------- transloadit/async_request.py | 75 +- transloadit/client.py | 554 ++---------- transloadit/endpoint_transport.py | 199 ----- transloadit/network.py | 29 + transloadit/request.py | 86 +- transloadit/stream.py | 88 -- transloadit/upload.py | 20 - 46 files changed, 612 insertions(+), 4225 deletions(-) delete mode 100644 contracts/api2-contract.json.gz delete mode 100644 contracts/api2-contract.lock.json delete mode 100644 docs/api-coverage.md delete mode 100644 examples/api2-devdock-assembly-lifecycle/main.py delete mode 100644 examples/api2-devdock-template-lifecycle/main.py delete mode 100644 examples/api2-devdock-tus-assembly/main.py delete mode 100644 examples/api2-devdock-tus-resume-upload/main.py delete mode 100644 scripts/generate_endpoints.py delete mode 100644 tests/test_contract_endpoints.py delete mode 100644 tests/test_e2e_endpoints.py create mode 100644 tests/test_transport.py delete mode 100644 transloadit/_contract.py delete mode 100644 transloadit/endpoint_transport.py create mode 100644 transloadit/network.py delete mode 100644 transloadit/stream.py diff --git a/.gitattributes b/.gitattributes index abc19b0..49378f1 100644 --- a/.gitattributes +++ b/.gitattributes @@ -41,10 +41,4 @@ *.webp filter=lfs diff=lfs merge=lfs -text *.woff2 filter=lfs diff=lfs merge=lfs -text *.xlsx filter=lfs diff=lfs merge=lfs -text -*.zip filter=lfs diff=lfs merge=lfs -text -# Keep the generation input available in ordinary clones and source archives. -/contracts/*.gz -filter -diff -merge -text -/transloadit/client.py text eol=lf -/transloadit/async_client.py text eol=lf -/transloadit/_contract.py text eol=lf -/docs/api-coverage.md text eol=lf +*.zip filter=lfs diff=lfs merge=lfs -text \ No newline at end of file diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3bc5df8..53648b6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -40,9 +40,6 @@ jobs: - name: Install Dependencies run: poetry install - - name: Check generated API endpoints - run: python scripts/generate_endpoints.py --check - - name: Test with coverage if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.14' run: | @@ -134,4 +131,4 @@ jobs: env: TEST_NODE_PARITY: 0 run: | - poetry run pytest tests/test_e2e_upload.py tests/test_e2e_endpoints.py tests/test_examples.py -q --maxfail=1 --no-cov + poetry run pytest tests/test_e2e_upload.py tests/test_examples.py -q --maxfail=1 --no-cov diff --git a/CHANGELOG.md b/CHANGELOG.md index 49b5d67..420a317 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,24 +1,7 @@ ### 2.0.0 / Unreleased ### -* **Breaking Change**: Python 3.9, 3.10, and 3.11 are no longer supported. Installing 2.0 requires Python 3.12 or newer; upgrade the interpreter before upgrading the SDK. Applications that must stay on those older interpreters can pin `pytransloadit<2` (the latest 1.x release is 1.0.4). -* **Breaking Change**: Runtime dependencies now require `requests>=2.33,<3` and `urllib3>=2.7,<3`. Remove or update older pins in application requirements/constraints and regenerate the application lockfile; incompatible pins will prevent installation. -* The synchronous client API, imports, Assembly creation/polling, uploads, and Smart CDN signing remain compatible with 1.0.4 on supported interpreters. -* Added all 44 documented API operations to both sync and async clients: Assemblies, Assembly Notifications, Templates, Template Credentials, auth keys and token grants, DAM, statistics, Priority Job Slots, Billing, SSE and raw TUS. DAM operations marked alpha retain that status. The 16 separate-product storage/device/OAuth routes are tracked for 2.1 in #60. -* Pinned the canonical API2 contract with producer revision and byte hash. Low-level methods and the coverage table regenerate deterministically; CI checks the committed bytes without API2 access. High-level Assembly, Template and upload helpers remain handwritten. -* Added signed PATCH, multipart PUT Assembly replacement, optional bearer-token authentication and authorization-code/refresh-token issuance. SSE supports incremental events and context-managed cancellation/cleanup. Raw TUS preserves binary downloads and response headers, validates returned destinations and does not forward account credentials or follow redirects. -* Added explicit asyncio support with `AsyncTransloadit`, async request/assembly/template helpers, and `asyncio.sleep`-based polling. Resumable uploads stay on the existing TUS client, but run in worker threads so the event loop remains responsive instead of pretending the sync uploader is natively async. -* Async cancellation drains active multipart reads and resumable workers, including repeated cancellation, before releasing caller-owned files. Isolated public, token, SSE and raw TUS transports preserve proxy/TLS configuration without borrowing session or netrc account credentials. High-level TUS helpers validate metadata and preserve Assembly creation errors. -* Explicit bearer authentication wins over ambient netrc or session auth. Assembly capability requests isolate account credentials while preserving custom deployment worker hosts. Async multipart uploads retain text-mode file support, and polling continues through `ASSEMBLY_REPLAYING`. -* Preserved legacy HTTP Assembly URLs by upgrading known API hosts to HTTPS, and aligned regional host checks with the pinned contract. Async transports retain explicit session proxy settings. Text uploads use chunked transfer when encoding/newline conversion changes their byte length; worker cleanup also survives global event-loop shutdown. -* Async multipart requests preserve spaces and Unicode in filenames with safe header quoting. Isolated async calls use aiohttp's environment proxy policy, including proxy-only netrc authentication. -* Hardened upload and response edge cases: invalid service URLs and empty template IDs now fail fast, external absolute API URLs are no longer signed, sync TUS uploads now handle nameless streams and submit rate limits before uploading, sync non-resumable retries rewind seekable files and reject non-seekable retry streams, sync/async polling rate-limit retries reset after successful polls and cap repeated rate limits, async form fields match sync boolean serialization, async TUS cancellation waits for worker cleanup, async rate-limit backoff honors server `retryIn`, Smart CDN signing rejects invalid workspace slugs/reserved query keys, and sync non-JSON responses fall back to response text. -* Hardened sync and async request handling by preserving custom `auth` constraints, quoting path IDs, and keeping explicit/custom service URLs compatible with local, CI, and [Transloadit Gateway](https://github.com/transloadit/gateway) deployments. -* Fixed sync and async template creation to send the current API `template` payload shape. -* The dependency refresh already released in 1.0.4 remains available to 1.x users; 2.0 removes the old-interpreter lockfile variants and requires the newer HTTP stack on every supported runtime. -* Updated development and documentation tooling, including `pytest` 9.0.3, `Sphinx` 9.1, `sphinx-autobuild` 2025.8, `coverage` 7.14, `tox` 4.54, and `requests-mock` 1.12. -* Updated CI and local Docker test coverage to a representative Python 3.12, 3.13, and 3.14 matrix. -* Migrated package metadata to the modern `[project]` format used by Poetry 2. -* Source contributors need Poetry 2.4.1 for the documented Docker/CI toolchain; isolated package builds require `poetry-core>=2.2,<3`. Normal `pip` installation installs the build backend automatically when needed. -* Refreshed GitHub Actions, release documentation, and Sphinx docs that still referenced older runtime/tooling assumptions. +* Added `AsyncTransloadit` with asyncio support for the existing synchronous client's Assembly, Template and billing methods, plus Smart CDN URL signing. Polling uses `asyncio.sleep`; resumable uploads run tuspy in worker threads. +* **Breaking Change**: Python 3.12 or newer is required. Upgrade development, CI and deployment interpreters before installing 2.0. Applications that need Python 3.9–3.11 can pin `pytransloadit<2` (latest 1.x: 1.0.4). +* **Upgrade notes**: Update application constraints for `requests>=2.33,<3` and `urllib3>=2.7,<3`, then regenerate your lockfile. Existing synchronous imports and methods remain available; asyncio applications can use `async with AsyncTransloadit(...)` and await network operations. Keep file context managers open around awaited uploads; cancellation waits for active file reads and resumable upload workers to finish. ### 1.0.4 / 2026-05-20 ### * Refreshed locked runtime and development dependencies, including `aiohttp` 3.13.5, `idna` 3.15, `pygments` 2.20.0, Python-version-specific `requests` updates, and `tuspy` 1.1.0. diff --git a/README.md b/README.md index 8fb569d..d2b8cf0 100644 --- a/README.md +++ b/README.md @@ -83,70 +83,14 @@ requested deadline; keep file context managers open around the awaited call. If you do not use `async with`, call `await tl.aclose()` when you are done with the session. -## API endpoint coverage - -Both clients expose all **44 documented API operations**: Assemblies and SSE, -Templates, Template Credentials, auth keys and token issuance, DAM, statistics, -Billing, job slots, Assembly Notifications, and the six raw TUS operations. -See the [complete coverage table and generation instructions](docs/api-coverage.md). -The five DAM operations marked alpha retain that status. The 16 separate-product -routes deferred to 2.1 are tracked in [#60](https://github.com/transloadit/python-sdk/issues/60). - -Ordinary GET methods take `params`, and other methods take `data`, as dictionaries -of the API's normalized request fields. Responses expose `.data`, `.status_code` -and `.headers`. For example, `await tl.list_auth_keys()` retrieves auth keys. -Check the endpoint reference for field names and required scopes. Signed requests -remain the default. To use a bearer token, pass -`bearer_token=token` to either client (the Auth Secret can be `None`). -`issue_bearer_token(data)` supports the contract's client-credentials, -authorization-code and refresh-token grants; omitted `grant_type` keeps the -client-credentials default. Tokens are not refreshed automatically. - -Isolated transports preserve network configuration. Sync calls honor environment -proxies and `REQUESTS_CA_BUNDLE` / `CURL_CA_BUNDLE`; async calls retain an injected -aiohttp session's DNS/TLS connector, explicit proxy/auth and `trust_env` setting, -or use environment proxies by default. Public, token, SSE and raw TUS calls use isolated -sessions so injected cookies, default account auth and netrc credentials cannot -be forwarded accidentally. Explicit bearer authentication also takes precedence -over netrc and injected session authentication. - -Assembly get/cancel requests use the same credential isolation. When `service` -points to a custom deployment, its returned Assembly worker hosts remain supported, -including for high-level polling. The default Transloadit service restricts these -requests to its API hosts; neither mode follows redirects or accepts URL credentials. -Legacy HTTP `assembly_url` values on known Transloadit API hosts are upgraded to -HTTPS automatically. Both clients use the pinned contract's regional-host pattern. - -SSE uses the returned Assembly `update_stream_url` and a context manager: - -```python -# Inside an async function, after creating an Assembly: -async with tl.stream_assembly_status(created.data["update_stream_url"]) as events: - async for event in events: - print(event.event, event.data) -``` - -The sync equivalent uses `with` and `for`. Each event has `event`, parsed `data`, -`id`, `retry` and `terminal` attributes. Unknown events are delivered unchanged. -The stream stops on a terminal event; exiting the context, including cancellation, -closes the connection. A terminal event or disconnect does **not** establish -processing success: fetch `assembly_ssl_url` and inspect `ok`/`error`. -HTTP errors raise `transloadit.stream.StreamError` with `status_code`; streams -do not reconnect or replay automatically. EOF ends iteration even without a -terminal event, and transport failures retain requests/urllib3 or aiohttp exception -types. Read inactivity defaults to 120 seconds, -and events are capped at 1 MiB; use `read_timeout` and `max_event_size` to adjust. - -For low-level resumable control, `tus_options(assembly)` and -`create_upload(assembly, headers=..., body=...)` take the Assembly response, pairing -its `tus_url` with `assembly_ssl_url`. Successful creation exposes a validated -`.upload_url`, suitable for persisting and passing to `get_upload_offset`, -`patch_upload`, `download_upload` or `delete_upload`. Supply TUS fields such as -`Upload-Length` and `Upload-Offset` through `headers`, and supply base64-encoded -`filename` / `fieldname` entries in `Upload-Metadata` when creating uploads; the -client adds protocol defaults and the Assembly metadata. Downloads return bytes, including JSON-looking -files. These raw methods return HTTP errors as `Response` objects; inspect status -codes. The high-level Assembly/tuspy helpers still handle normal uploads and polling. +## Client features + +`AsyncTransloadit` mirrors the existing synchronous client: Assembly creation, +retrieval, listing and cancellation; Template creation, retrieval, listing, +updates and deletion; monthly billing; and Smart CDN URL signing. Use the +Assembly helpers for multipart or resumable uploads and completion polling. +Await the async client's network methods; local factories and URL signing stay +synchronous. ## Examples diff --git a/contracts/api2-contract.json.gz b/contracts/api2-contract.json.gz deleted file mode 100644 index f8543d54b8d2eaf40e7ed15a5518857e8f645348..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1012247 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 Y6zVb%=8dgOBhA{$ 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 WF?T}f^J1!PT{&+It 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