render 1.1.0__tar.gz → 1.3.0__tar.gz

{render-1.1.0 → render-1.3.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.3.0] - 2026-10-17
+
+### Added
+
+- (Sandboxes) `sandboxes.create()` accepts `network_policy=NetworkPolicy(type="allow-list", rules=[EgressRule(domain="pypi.org")])` to restrict outbound traffic. Rules support domain names and wildcard domains such as `*.pypi.org`. `EgressRule.protocol` defaults to `"https"`. Both the sync and async clients support these rules.
+- (REST API) Generated clients include flows, flow runs, run steps, and individual build retrieval.
+
+### Changed
+
+- **Breaking:** (Sandboxes) `Sandbox.network_policy` is a `NetworkPolicy` object with `type` and `rules` instead of a string. Read `sandbox.network_policy.type` to get the policy type. String inputs such as `network_policy="deny-all"` still work when you create a sandbox.
+- **Breaking:** (REST API) Removed `create_blueprint` and its request and response models. Build source Git fields use `docker_context` instead of `base_dir`. Build lists return `BuildWithCursor` entries with `build` and `cursor` fields instead of bare `Build` entries.
+- (REST API) Service creation can omit `runtime` when `build_source_id` is set. `auto_deploy` is deprecated; use `auto_deploy_trigger`. Sandbox status includes `suspending`. Service event list entries include a `cursor`.
+- (Workflows) The SDK sends import and startup timestamps with the initial input request. The runtime can use these timestamps to measure SDK import and startup time.
+
+## [1.2.0] - 2026-09-23
+
+### Added
+
+- (Workflows) `start_task()` and `run_task()` accept a keyword-only `idempotency_key`, which makes starting a run safe to retry: repeating a call with the same key within 24 hours returns the run the first call started
+- (Workflows) `ctx.metadata` exposes `task_run_id`, `root_task_run_id` and `parent_task_run_id` for the running task. The IDs come from the task's initial input, so reading them does not make a network request; each is `None` when unavailable
+- (Sandboxes) Snapshot names: `snapshots.create()` accepts `name`, `sandboxes.create()` accepts `snapshot_name` to start from the snapshot that name resolves to, and `Snapshot` exposes `name`. Passing both `snapshot_id` and `snapshot_name` raises `ValueError`
+
+### Changed
+
+- Regenerated the REST client from the latest OpenAPI schema: blueprint creation, `include_previews` when listing build sources, and allowed domains on sandbox network policies. `Deploy` no longer has a `build_id` field
+
 ## [1.1.0] - 2026-09-10
 
 ### Added

{render-1.1.0 → render-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: render
-Version: 1.1.0
+Version: 1.3.0
 Summary: Python SDK for Render Workflows
 Author-email: Render <support@render.com>
 License-File: LICENSE
@@ -102,6 +102,17 @@ from tasks_b import app as app_b
 combined = Workflows.from_workflows(app_a, app_b)
 ```
 
+### Task run IDs
+
+The task context exposes a read-only `ctx.metadata` object with
+`task_run_id`, `root_task_run_id`, and `parent_task_run_id` fields. The SDK reads
+them from the initial input response and keeps them for that execution, so
+accessing metadata does not make a network request.
+
+For a root run, `ctx.metadata.root_task_run_id` equals
+`ctx.metadata.task_run_id` and `ctx.metadata.parent_task_run_id` is `None`.
+IDs are `None` when unavailable.
+
 ### Running the Local Task Server
 
 For local development, use the Render CLI:
@@ -159,6 +170,19 @@ for event in render.workflows.task_run_events([task_run.id]):
 runs = render.workflows.list_task_runs(ListTaskRunsParams(limit=10))
 ```
 
+#### Idempotency Keys
+
+Pass an `idempotency_key` to make starting a run safe to retry. Repeating a call
+with the same key within 24 hours returns the run the first call started instead
+of starting another one, so a client that retries after a timeout does not run
+the task twice. Keys are scoped to a single workflow version.
+
+```python
+task_run = render.workflows.start_task(
+    "my-workflow/charge", [order_id], idempotency_key=f"charge-{order_id}"
+)
+```
+
 #### Async Usage
 
 For async contexts (e.g. FastAPI), use `RenderAsync`:

{render-1.1.0 → render-1.3.0}/README.md

@@ -77,6 +77,17 @@ from tasks_b import app as app_b
 combined = Workflows.from_workflows(app_a, app_b)
 ```
 
+### Task run IDs
+
+The task context exposes a read-only `ctx.metadata` object with
+`task_run_id`, `root_task_run_id`, and `parent_task_run_id` fields. The SDK reads
+them from the initial input response and keeps them for that execution, so
+accessing metadata does not make a network request.
+
+For a root run, `ctx.metadata.root_task_run_id` equals
+`ctx.metadata.task_run_id` and `ctx.metadata.parent_task_run_id` is `None`.
+IDs are `None` when unavailable.
+
 ### Running the Local Task Server
 
 For local development, use the Render CLI:
@@ -134,6 +145,19 @@ for event in render.workflows.task_run_events([task_run.id]):
 runs = render.workflows.list_task_runs(ListTaskRunsParams(limit=10))
 ```
 
+#### Idempotency Keys
+
+Pass an `idempotency_key` to make starting a run safe to retry. Repeating a call
+with the same key within 24 hours returns the run the first call started instead
+of starting another one, so a client that retries after a timeout does not run
+the task twice. Keys are scoped to a single workflow version.
+
+```python
+task_run = render.workflows.start_task(
+    "my-workflow/charge", [order_id], idempotency_key=f"charge-{order_id}"
+)
+```
+
 #### Async Usage
 
 For async contexts (e.g. FastAPI), use `RenderAsync`:

{render-1.1.0 → render-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "render"
-version = "1.1.0"
+version = "1.3.0"
 description = "Python SDK for Render Workflows"
 authors = [{ name = "Render", email = "support@render.com" }]
 readme = "README.md"

{render-1.1.0 → render-1.3.0}/render/__init__.py

@@ -33,7 +33,10 @@ Async REST API access:
     result = await task_run
 """
 
-__version__ = "1.1.0"
+# Must stay the first import: it records when SDK import began.
+from render import _startup
+
+__version__ = "1.3.0"
 
 # Render/RenderAsync are lazy-loaded so the workflow worker path stays fast.
 from typing import TYPE_CHECKING
@@ -42,6 +45,7 @@ from render.workflows import (
     Options,
     Retry,
     TaskContext,
+    TaskRunMetadata,
     Workflows,
     start,
     task,
@@ -58,6 +62,7 @@ __all__ = [
     "RenderAsync",  # Async REST API client
     "Workflows",  # Task definition
     "TaskContext",  # First parameter of every task
+    "TaskRunMetadata",
     # Configuration
     "Options",
     "Retry",
@@ -96,3 +101,5 @@ def __dir__() -> list[str]:
 #
 # Raw API access available via:
 #   from render.public_api import AuthenticatedClient
+
+_startup.mark_import_finished()

render-1.3.0/render/_startup.py

@@ -0,0 +1,34 @@
+"""Wall-clock startup timestamps reported to the server on ``GET /input``.
+
+Imported first by ``render/__init__.py`` so the import start is the earliest
+point SDK code runs. Stdlib only, to stay cheap.
+"""
+
+import time
+
+_import_started_ns: int | None = time.time_ns()
+_import_finished_ns: int | None = None
+_sdk_started_ns: int | None = None
+
+
+def mark_import_finished() -> None:
+    global _import_finished_ns
+    if _import_finished_ns is None:
+        _import_finished_ns = time.time_ns()
+
+
+def mark_sdk_started() -> None:
+    global _sdk_started_ns
+    if _sdk_started_ns is None:
+        _sdk_started_ns = time.time_ns()
+
+
+def input_query() -> str:
+    """Return ``?k=v&...`` for the timestamps that were captured, or ``""``."""
+    params = (
+        ("sdk_import_started_at", _import_started_ns),
+        ("sdk_import_finished_at", _import_finished_ns),
+        ("sdk_started_at", _sdk_started_ns),
+    )
+    parts = [f"{name}={value}" for name, value in params if value]
+    return "?" + "&".join(parts) if parts else ""

{render-1.1.0 → render-1.3.0}/render/client/tests/test_client.py

@@ -118,6 +118,62 @@ async def test_start_task_success(
     mock_create_task_asyncio.assert_called_once()
 
 
+@pytest.mark.asyncio
+async def test_start_task_omits_idempotency_key_when_not_given(
+    mock_create_task_asyncio, workflows_service, mock_task_run
+):
+    mock_create_task_asyncio.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    await workflows_service.start_task("test-task", {"input": "data"})
+
+    body = mock_create_task_asyncio.call_args.kwargs["body"]
+    assert "idempotencyKey" not in body.to_dict()
+
+
+@pytest.mark.asyncio
+async def test_start_task_sends_idempotency_key(
+    mock_create_task_asyncio, workflows_service, mock_task_run
+):
+    mock_create_task_asyncio.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    await workflows_service.start_task(
+        "test-task", {"input": "data"}, idempotency_key="order-42"
+    )
+
+    body = mock_create_task_asyncio.call_args.kwargs["body"]
+    assert body.to_dict()["idempotencyKey"] == "order-42"
+
+
+@pytest.mark.asyncio
+async def test_run_task_sends_idempotency_key(
+    mocker,
+    mock_create_task_asyncio,
+    workflows_service,
+    mock_task_run,
+    mock_task_run_details,
+):
+    mock_create_task_asyncio.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+    mocker.patch.object(
+        AwaitableTaskRun,
+        "_wait_for_completion",
+        new_callable=mocker.AsyncMock,
+        return_value=mock_task_run_details,
+    )
+
+    await workflows_service.run_task(
+        "test-task", {"input": "data"}, idempotency_key="order-42"
+    )
+
+    body = mock_create_task_asyncio.call_args.kwargs["body"]
+    assert body.idempotency_key == "order-42"
+
+
 @pytest.mark.asyncio
 async def test_start_task_failure(mock_create_task_asyncio, workflows_service):
     """Test task start failure."""

{render-1.1.0 → render-1.3.0}/render/client/tests/test_workflows_sync.py

@@ -117,6 +117,58 @@ def test_start_task_success(
     mock_create_task_sync.assert_called_once()
 
 
+def test_start_task_omits_idempotency_key_when_not_given(
+    mock_create_task_sync, sync_workflows_service, mock_task_run
+):
+    mock_create_task_sync.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    sync_workflows_service.start_task("test-task", {"input": "data"})
+
+    body = mock_create_task_sync.call_args.kwargs["body"]
+    assert "idempotencyKey" not in body.to_dict()
+
+
+def test_start_task_sends_idempotency_key(
+    mock_create_task_sync, sync_workflows_service, mock_task_run
+):
+    mock_create_task_sync.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    sync_workflows_service.start_task(
+        "test-task", {"input": "data"}, idempotency_key="order-42"
+    )
+
+    body = mock_create_task_sync.call_args.kwargs["body"]
+    assert body.to_dict()["idempotencyKey"] == "order-42"
+
+
+def test_run_task_sends_idempotency_key(
+    mocker,
+    mock_create_task_sync,
+    sync_workflows_service,
+    mock_task_run,
+    mock_task_run_details,
+):
+    mock_create_task_sync.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+    mocker.patch.object(
+        sync_workflows_service,
+        "_task_run_completed_with_sse",
+        return_value=mock_task_run_details,
+    )
+
+    sync_workflows_service.run_task(
+        "test-task", {"input": "data"}, idempotency_key="order-42"
+    )
+
+    body = mock_create_task_sync.call_args.kwargs["body"]
+    assert body.idempotency_key == "order-42"
+
+
 def test_start_task_failure(mock_create_task_sync, sync_workflows_service):
     """Test task start failure."""
 

{render-1.1.0 → render-1.3.0}/render/client/workflows.py

@@ -184,6 +184,8 @@ class WorkflowsService:
         self,
         task_slug: TaskSlug,
         input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> AwaitableTaskRun:
         """Start a task and return an awaitable task run without waiting for completion.
 
@@ -203,6 +205,9 @@ class WorkflowsService:
             input_data: The input data for the task. Can be either:
                 - A list for positional arguments: [arg1, arg2, arg3]
                 - A dict for named parameters: {"param1": value1, "param2": value2}
+            idempotency_key: Optional client-generated key that makes this call safe
+                to retry. Repeating a call with the same key within 24 hours returns
+                the task run the first call started instead of starting another one.
 
         Returns:
             AwaitableTaskRun: A task run that can be awaited for the result
@@ -212,7 +217,11 @@ class WorkflowsService:
             ServerError: For 5xx server errors and network failures
             TimeoutError: If the request times out
         """
-        response = (await self._create_task_api_call(task_slug, input_data)).parsed
+        response = (
+            await self._create_task_api_call(
+                task_slug, input_data, idempotency_key=idempotency_key
+            )
+        ).parsed
 
         return AwaitableTaskRun(response, self)
 
@@ -220,6 +229,8 @@ class WorkflowsService:
         self,
         task_slug: TaskSlug,
         input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> TaskRunDetails:
         """Start a task and wait for it to complete, returning the result.
 
@@ -231,6 +242,9 @@ class WorkflowsService:
             input_data: The input data for the task. Can be either:
                 - A list for positional arguments: [arg1, arg2, arg3]
                 - A dict for named parameters: {"param1": value1, "param2": value2}
+            idempotency_key: Optional client-generated key that makes this call safe
+                to retry. Repeating a call with the same key within 24 hours returns
+                the task run the first call started instead of starting another one.
 
         Returns:
             TaskRunDetails: The completed task run details
@@ -241,12 +255,18 @@ class WorkflowsService:
             TimeoutError: If the request times out
             TaskRunError: If the task run fails with an error
         """
-        task_run = await self.start_task(task_slug, input_data)
+        task_run = await self.start_task(
+            task_slug, input_data, idempotency_key=idempotency_key
+        )
         return await task_run
 
     @handle_http_errors("create task")
     async def _create_task_api_call(
-        self, task_slug: TaskSlug, input_data: TaskData
+        self,
+        task_slug: TaskSlug,
+        input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> Response[Error | TaskRun]:
         """Internal method to make the create task API call."""
         # Convert dict to TaskDataType1 for named parameters
@@ -260,6 +280,7 @@ class WorkflowsService:
         run_task = RunTask(
             task=task_slug,
             input_=task_data_input,
+            idempotency_key=idempotency_key if idempotency_key is not None else UNSET,
         )
 
         # Make the API call

{render-1.1.0 → render-1.3.0}/render/client/workflows_sync.py

@@ -105,6 +105,8 @@ class SyncWorkflowsService:
         self,
         task_slug: TaskSlug,
         input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> TaskRun:
         """Start a task and return the task run without waiting for completion.
 
@@ -118,6 +120,9 @@ class SyncWorkflowsService:
             input_data: The input data for the task. Can be either:
                 - A list for positional arguments: [arg1, arg2, arg3]
                 - A dict for named parameters: {"param1": value1, "param2": value2}
+            idempotency_key: Optional client-generated key that makes this call safe
+                to retry. Repeating a call with the same key within 24 hours returns
+                the task run the first call started instead of starting another one.
 
         Returns:
             TaskRun: The created task run
@@ -127,12 +132,16 @@ class SyncWorkflowsService:
             ServerError: For 5xx server errors and network failures
             TimeoutError: If the request times out
         """
-        return self._create_task_api_call(task_slug, input_data).parsed
+        return self._create_task_api_call(
+            task_slug, input_data, idempotency_key=idempotency_key
+        ).parsed
 
     def run_task(
         self,
         task_slug: TaskSlug,
         input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> TaskRunDetails:
         """Start a task and wait for it to complete, returning the result.
 
@@ -143,6 +152,9 @@ class SyncWorkflowsService:
             input_data: The input data for the task. Can be either:
                 - A list for positional arguments: [arg1, arg2, arg3]
                 - A dict for named parameters: {"param1": value1, "param2": value2}
+            idempotency_key: Optional client-generated key that makes this call safe
+                to retry. Repeating a call with the same key within 24 hours returns
+                the task run the first call started instead of starting another one.
 
         Returns:
             TaskRunDetails: The completed task run details
@@ -153,7 +165,9 @@ class SyncWorkflowsService:
             TimeoutError: If the request times out
             TaskRunError: If the task run fails with an error
         """
-        task_run = self.start_task(task_slug, input_data)
+        task_run = self.start_task(
+            task_slug, input_data, idempotency_key=idempotency_key
+        )
 
         # If already in a terminal state, just get the details
         status = task_run.status.value
@@ -183,7 +197,11 @@ class SyncWorkflowsService:
 
     @handle_http_errors("create task")
     def _create_task_api_call(
-        self, task_slug: TaskSlug, input_data: TaskData
+        self,
+        task_slug: TaskSlug,
+        input_data: TaskData,
+        *,
+        idempotency_key: str | None = None,
     ) -> Response[Error | TaskRun]:
         """Internal method to make the create task API call."""
         # Convert dict to TaskDataType1 for named parameters
@@ -197,6 +215,7 @@ class SyncWorkflowsService:
         run_task = RunTask(
             task=task_slug,
             input_=task_data_input,
+            idempotency_key=idempotency_key if idempotency_key is not None else UNSET,
         )
 
         # Make the API call

render-1.3.0/render/experimental/object/tests/rate_limit.py

@@ -0,0 +1,59 @@
+"""Retry 429s in the object storage e2e tests.
+
+Every PR's E2E job shares one staging account, so concurrent runs trip the API
+rate limit. RateLimitError doesn't carry the Retry-After header, so back off
+exponentially with jitter instead.
+"""
+
+import asyncio
+import functools
+import random
+from collections.abc import Awaitable, Callable
+from typing import ParamSpec, TypeVar
+
+from render.client.errors import RateLimitError
+from render.experimental.object.client import ObjectClient
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# Total window is ~60 seconds before jitter
+MAX_ATTEMPTS = 7
+INITIAL_DELAY_S = 1.0
+MAX_DELAY_S = 16.0
+
+
+def retry_rate_limited(
+    func: Callable[P, Awaitable[R]],
+    *,
+    initial_delay_s: float = INITIAL_DELAY_S,
+) -> Callable[P, Awaitable[R]]:
+    @functools.wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        for attempt in range(MAX_ATTEMPTS):
+            try:
+                return await func(*args, **kwargs)
+            except RateLimitError:
+                if attempt >= MAX_ATTEMPTS - 1:
+                    raise
+                delay = min(initial_delay_s * 2**attempt, MAX_DELAY_S)
+                await asyncio.sleep(delay * random.uniform(0.5, 1.5))  # noqa: S311
+        raise AssertionError("unreachable")  # pragma: no cover
+
+    return wrapper
+
+
+def patch_rate_limit_retries(
+    client: ObjectClient, *, initial_delay_s: float = INITIAL_DELAY_S
+) -> None:
+    """Wrap the client's API methods in place.
+
+    ScopedObjectClient delegates to these, so scoped() is covered too.
+    """
+    for name in ("put", "get", "delete", "list"):
+        method = getattr(client, name)
+        setattr(
+            client,
+            name,
+            retry_rate_limited(method, initial_delay_s=initial_delay_s),
+        )

{render-1.1.0 → render-1.3.0}/render/experimental/object/tests/test_e2e.py

@@ -14,7 +14,9 @@ import uuid
 
 import pytest
 
+from render.experimental.object.client import ObjectClient
 from render.experimental.object.e2e_helpers import object_storage_crud_check
+from render.experimental.object.tests.rate_limit import patch_rate_limit_retries
 from render.render_async import RenderAsync
 
 # ---------------------------------------------------------------------------
@@ -42,6 +44,13 @@ def render():
     )
 
 
+@pytest.fixture
+def objects(render) -> ObjectClient:
+    client = render.client.experimental.storage.objects
+    patch_rate_limit_retries(client)
+    return client
+
+
 @pytest.fixture
 def owner_id():
     return os.environ["RENDER_E2E_OWNER_ID"]
@@ -57,20 +66,14 @@ def region():
 # ---------------------------------------------------------------------------
 class TestObjectClientE2E:
     @pytest.mark.asyncio
-    async def test_crud_cycle(self, render, owner_id, region):
+    async def test_crud_cycle(self, objects, owner_id, region):
         """Full PUT → LIST → GET → DELETE → verify-deletion cycle."""
-        await object_storage_crud_check(
-            render.client.experimental.storage.objects,
-            owner_id,
-            region,
-        )
+        await object_storage_crud_check(objects, owner_id, region)
 
     @pytest.mark.asyncio
-    async def test_scoped_accessor(self, render, owner_id, region):
+    async def test_scoped_accessor(self, objects, owner_id, region):
         """Verify scoped() wiring with a simple PUT/GET/DELETE."""
-        scoped = render.client.experimental.storage.objects.scoped(
-            owner_id=owner_id, region=region
-        )
+        scoped = objects.scoped(owner_id=owner_id, region=region)
         key = f"e2e-test/{uuid.uuid4()}/scoped-test.txt"
 
         try:
@@ -93,11 +96,10 @@ class TestObjectClientE2E:
 )
 class TestObjectClientPagination:
     @pytest.mark.asyncio
-    async def test_pagination(self, render):
+    async def test_pagination(self, objects):
         """Walk all pages with limit=2, verify multiple pages returned."""
         owner_id = os.environ["RENDER_E2E_PAGINATION_OWNER_ID"]
         region = os.environ.get("RENDER_E2E_REGION", "oregon")
-        objects = render.client.experimental.storage.objects
 
         page_size = 2
         cursor = None

render-1.3.0/render/experimental/object/tests/test_rate_limit.py

@@ -0,0 +1,75 @@
+"""Tests for the e2e rate-limit retry wrapper."""
+
+from types import SimpleNamespace
+
+import pytest
+
+from render.client.errors import ClientError, RateLimitError
+from render.experimental.object.client import ObjectClient
+from render.experimental.object.tests.rate_limit import (
+    MAX_ATTEMPTS,
+    patch_rate_limit_retries,
+    retry_rate_limited,
+)
+from render.experimental.object.types import ListObjectsResponse
+
+
+@pytest.mark.asyncio
+async def test_retries_rate_limit_until_success():
+    calls = 0
+
+    async def fn() -> str:
+        nonlocal calls
+        calls += 1
+        if calls < 3:
+            raise RateLimitError("list objects failed: rate limit exceeded")
+        return "ok"
+
+    assert await retry_rate_limited(fn, initial_delay_s=0)() == "ok"
+    assert calls == 3
+
+
+@pytest.mark.asyncio
+async def test_reraises_after_max_attempts():
+    calls = 0
+
+    async def fn() -> None:
+        nonlocal calls
+        calls += 1
+        raise RateLimitError("rate limit exceeded")
+
+    with pytest.raises(RateLimitError):
+        await retry_rate_limited(fn, initial_delay_s=0)()
+    assert calls == MAX_ATTEMPTS
+
+
+@pytest.mark.asyncio
+async def test_does_not_retry_other_client_errors():
+    calls = 0
+
+    async def fn() -> None:
+        nonlocal calls
+        calls += 1
+        raise ClientError("object not found")
+
+    with pytest.raises(ClientError):
+        await retry_rate_limited(fn, initial_delay_s=0)()
+    assert calls == 1
+
+
+@pytest.mark.asyncio
+async def test_patch_covers_scoped_client(mocker):
+    client = ObjectClient(SimpleNamespace())
+    list_mock = mocker.AsyncMock(
+        side_effect=[
+            RateLimitError("rate limit exceeded"),
+            ListObjectsResponse(objects=[], next_cursor=None, has_next=False),
+        ]
+    )
+    mocker.patch.object(client, "list", new=list_mock)
+
+    patch_rate_limit_retries(client, initial_delay_s=0)
+    response = await client.scoped(owner_id="tea-test", region="oregon").list()
+
+    assert response.objects == []
+    assert list_mock.await_count == 2