render 1.4.0__tar.gz → 1.6.0__tar.gz

{render-1.4.0 → render-1.6.0}/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [1.6.0] - 2026-10-29
+
+### Added
+
+- (Sandboxes) Sandbox images: `sandboxes.images.import_()` imports an OCI image so sandboxes can start from it, `images.from_id()` fetches an image, and `images.wait_until_ready()` waits for the import to succeed. Private registries are supported with `registry_credentials`.
+- (Sandboxes) `sandboxes.create()` accepts `image`, an image ID or name.
+- (Workflows) Flow runs: `start_flow()`, `get_flow_run()`, `cancel_flow_run()`, and `list_flow_runs()` on `render.workflows` and the sync client.
+- `ErrorCode.INSUFFICIENT_TOKEN_SCOPE` for the `insufficient_token_scope` API error code.
+
+### Changed
+
+- (Sandboxes) The `sandboxes.create()` docs state that a `timeout_seconds` of `0` disables the sandbox lifetime limit. This is a documentation change; the SDK sends the value as before.
+
+### Deprecated
+
+- (Sandboxes) `sandboxes.builds`, `Build`, `BuildSource`, `RegistryCredential`, `BuildNotFoundError`, and `BuildNotReadyError`. Use `sandboxes.images`, `Image`, `ImageSource`, `RegistryCredentials`, `ImageNotFoundError`, and `ImageNotReadyError`.
+- (Sandboxes) The `build_id` and `build_name` arguments of `sandboxes.create()`. Use `image`.
+
+### Fixed
+
+- `AuditLogEvent` accepts `DeleteBuildSourceEvent`, `LinkBuildSourceEnvGroupEvent`, and `UnlinkBuildSourceEnvGroupEvent`. Before, the client raised `ValueError` on audit logs that contain these events.
+
+## [1.5.0] - 2026-10-27
+
+### Added
+
+- (Sandboxes) Sandboxes are out of experimental: use `render.sandboxes` and import from `render.sandbox`.
+- (Sandboxes) Sandbox groups: `create_group()`, `get_group()`, `update_group()`, and `sandbox_group_id` on `create()` and `list()`. `list_groups()` accepts `cursor` and `limit`.
+- (Sandboxes) `wait_until_running()`, `snapshots.wait_until_available()`, and a `wait` option on `create()` and `snapshots.create()`.
+- (Sandboxes) `SandboxPlan` hints the known plans; any plan string still works.
+
+### Changed
+
+- **Breaking:** (Sandboxes) Removed `render.experimental.sandboxes`; use `render.sandboxes`.
+(Sandboxes) `sandboxes.create()` `region` is deprecated and ignored.
+
+### Fixed
+
+- (Sandboxes) `copy_to()` cleans the remote path the same way as downloads.
+
 ## [1.4.0] - 2026-10-21
 
 ### Added

{render-1.4.0 → render-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: render
-Version: 1.4.0
+Version: 1.6.0
 Summary: Python SDK for Render Workflows
 Author-email: Render <support@render.com>
 License-File: LICENSE

{render-1.4.0 → render-1.6.0}/example/sandbox/main.py

@@ -9,7 +9,7 @@ import tempfile
 from pathlib import Path
 
 from render import RenderAsync
-from render.experimental.sandbox import SandboxClient, SandboxExecOutput
+from render.sandbox import SandboxClient, SandboxExecOutput
 
 
 async def run(sandboxes: SandboxClient, sandbox_id: str, command: str) -> None:
@@ -22,9 +22,10 @@ async def run(sandboxes: SandboxClient, sandbox_id: str, command: str) -> None:
 
 async def main() -> None:
     render = RenderAsync()
-    sandboxes = render.experimental.sandboxes
+    sandboxes = render.sandboxes
 
-    sandbox = await sandboxes.create()
+    # wait=True returns once the sandbox is running and can run commands.
+    sandbox = await sandboxes.create(wait=True)
     print(f"created {sandbox.id} ({sandbox.status})")
     try:
         await run(sandboxes, sandbox.id, "echo hello from render")

{render-1.4.0 → render-1.6.0}/pyproject.toml

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

{render-1.4.0 → render-1.6.0}/render/__init__.py

@@ -36,7 +36,7 @@ Async REST API access:
 # Must stay the first import: it records when SDK import began.
 from render import _startup
 
-__version__ = "1.4.0"
+__version__ = "1.6.0"
 
 # Render/RenderAsync are lazy-loaded so the workflow worker path stays fast.
 from typing import TYPE_CHECKING

{render-1.4.0 → render-1.6.0}/render/client/__init__.py

@@ -13,7 +13,14 @@ if TYPE_CHECKING:
     from render.client.client import Client
     from render.client.types import (
         CursorParam,
+        FlowData,
+        FlowRun,
+        FlowRunDetails,
+        FlowRunStatus,
+        FlowRunStatusParam,
+        FlowSlug,
         LimitParam,
+        ListFlowRunsParams,
         ListTaskRunsParams,
         OwnerIDParam,
         TaskData,
@@ -53,6 +60,13 @@ __all__ = [
     "LimitParam",
     "CursorParam",
     "OwnerIDParam",
+    "FlowData",
+    "FlowSlug",
+    "FlowRun",
+    "FlowRunDetails",
+    "FlowRunStatus",
+    "FlowRunStatusParam",
+    "ListFlowRunsParams",
     # Experimental exports
     "ExperimentalService",
     "StorageService",
@@ -86,6 +100,13 @@ _LAZY_ATTRS = {
     "LimitParam": ("render.client.types", "LimitParam"),
     "CursorParam": ("render.client.types", "CursorParam"),
     "OwnerIDParam": ("render.client.types", "OwnerIDParam"),
+    "FlowData": ("render.client.types", "FlowData"),
+    "FlowSlug": ("render.client.types", "FlowSlug"),
+    "FlowRun": ("render.client.types", "FlowRun"),
+    "FlowRunDetails": ("render.client.types", "FlowRunDetails"),
+    "FlowRunStatus": ("render.client.types", "FlowRunStatus"),
+    "FlowRunStatusParam": ("render.client.types", "FlowRunStatusParam"),
+    "ListFlowRunsParams": ("render.client.types", "ListFlowRunsParams"),
     "ExperimentalService": ("render.experimental", "ExperimentalService"),
     "StorageService": ("render.experimental", "StorageService"),
     "SyncExperimentalService": ("render.experimental", "SyncExperimentalService"),

render-1.6.0/render/client/_requests.py

@@ -0,0 +1,88 @@
+"""Request builders shared by the async and sync workflows clients.
+
+These are pure functions that turn SDK arguments into generated API request
+bodies and query arguments, so both clients build requests the same way.
+"""
+
+from typing import Any
+
+from render.client.types import (
+    FlowData,
+    FlowRunStatus,
+    FlowSlug,
+    ListFlowRunsParams,
+    TaskData,
+    TaskSlug,
+)
+from render.public_api.models.flow_input_type_1 import FlowInputType1
+from render.public_api.models.run_task import RunTask
+from render.public_api.models.start_flow_run import StartFlowRun
+from render.public_api.models.task_data_type_1 import TaskDataType1
+from render.public_api.types import UNSET
+
+
+def run_task_body(
+    task_slug: TaskSlug,
+    input_data: TaskData,
+    idempotency_key: str | None,
+) -> RunTask:
+    """Build the request body for running a task."""
+    task_input: TaskDataType1 | list[Any]
+    if isinstance(input_data, dict):
+        task_input = TaskDataType1.from_dict(input_data)
+    else:
+        task_input = input_data
+
+    return RunTask(
+        task=task_slug,
+        input_=task_input,
+        idempotency_key=idempotency_key if idempotency_key is not None else UNSET,
+    )
+
+
+def start_flow_run_body(
+    flow_slug: FlowSlug,
+    input_data: FlowData,
+    idempotency_key: str | None,
+) -> StartFlowRun:
+    """Build the request body for starting a flow run."""
+    flow_input: FlowInputType1 | list[Any]
+    if isinstance(input_data, dict):
+        flow_input = FlowInputType1.from_dict(input_data)
+    else:
+        flow_input = input_data
+
+    return StartFlowRun(
+        flow=flow_slug,
+        input_=flow_input,
+        idempotency_key=idempotency_key if idempotency_key is not None else UNSET,
+    )
+
+
+def list_flow_runs_query(params: ListFlowRunsParams | None) -> dict[str, Any]:
+    """Translate ListFlowRunsParams into keyword arguments for list_flow_runs.
+
+    Unset filters become UNSET so they are left out of the query string.
+    """
+    if params is None:
+        params = ListFlowRunsParams()
+
+    def or_unset(value: Any) -> Any:
+        return value if value is not None else UNSET
+
+    status = (
+        [FlowRunStatus(s) for s in params.status]
+        if params.status is not None
+        else UNSET
+    )
+
+    return {
+        "limit": or_unset(params.limit),
+        "cursor": or_unset(params.cursor),
+        "flow_slug": or_unset(params.flow_slug),
+        "flow_id": or_unset(params.flow_id),
+        "status": status,
+        "owner_id": or_unset(params.owner_id),
+        "workflow_version_id": or_unset(params.workflow_version_id),
+        "workflow_id": or_unset(params.workflow_id),
+    }

{render-1.4.0 → render-1.6.0}/render/client/client.py

@@ -7,6 +7,7 @@ import os
 
 from render.client.workflows import WorkflowsService
 from render.experimental.experimental import ExperimentalService
+from render.experimental.sandbox.client import SandboxClient
 from render.public_api.client import AuthenticatedClient
 from render.public_api.client import Client as PublicApiClient
 from render.version import get_user_agent
@@ -23,6 +24,7 @@ class Client:
         token: The authentication token
         base_url: The API base URL
         workflows: Service client for workflow operations
+        sandboxes: Client for sandbox operations
         experimental: Service client for experimental features
     """
 
@@ -107,4 +109,9 @@ class Client:
 
         # Initialize service clients
         self.workflows = WorkflowsService(self)
+        self.sandboxes = SandboxClient(
+            self.internal,
+            default_owner_id=self.owner_id,
+            default_region=self.region,
+        )
         self.experimental = ExperimentalService(self)

{render-1.4.0 → render-1.6.0}/render/client/tests/test_client.py

@@ -3,17 +3,27 @@
 
 import datetime
 import json
+from typing import Any
 
 import pytest
 
-from render.client import Client, ListTaskRunsParams, WorkflowsService
+from render.client import (
+    Client,
+    ListFlowRunsParams,
+    ListTaskRunsParams,
+    WorkflowsService,
+)
 from render.client.errors import ClientError, ServerError
 from render.client.workflows import AwaitableTaskRun
 from render.public_api.models.error import Error
+from render.public_api.models.flow_run import FlowRun
+from render.public_api.models.flow_run_details import FlowRunDetails
+from render.public_api.models.flow_run_status import FlowRunStatus
+from render.public_api.models.flow_run_with_cursor import FlowRunWithCursor
 from render.public_api.models.task_run import TaskRun
 from render.public_api.models.task_run_details import TaskRunDetails
 from render.public_api.models.task_run_status import TaskRunStatus
-from render.public_api.types import Response
+from render.public_api.types import UNSET, Response
 
 
 # Fixtures
@@ -433,3 +443,163 @@ async def test_task_run_events_raises_on_http_error(
     with pytest.raises(ServerError):
         async for _ in workflows_service.task_run_events(["trn-test123"]):
             pass
+
+
+# Flow runs
+
+
+def new_flow_run(**overrides) -> FlowRun:
+    """Build a FlowRun, overriding only the fields a test cares about."""
+    fields: dict[str, Any] = {
+        "id": "frn-test123",
+        "flow_id": "flw-test123",
+        "status": FlowRunStatus.PENDING,
+    }
+    fields.update(overrides)
+    return FlowRun(**fields)
+
+
+def new_flow_run_details(**overrides) -> FlowRunDetails:
+    """Build a FlowRunDetails, overriding only the fields a test cares about."""
+    fields: dict[str, Any] = {
+        "id": "frn-test123",
+        "flow_id": "flw-test123",
+        "status": FlowRunStatus.SUCCEEDED,
+        "input_": [42],
+        "results": [84],
+        "attempts": [],
+    }
+    fields.update(overrides)
+    return FlowRunDetails(**fields)
+
+
+def ok(parsed, status_code=200) -> Response:
+    return Response(status_code=status_code, content=b"", headers={}, parsed=parsed)
+
+
+@pytest.fixture
+def mock_start_flow_run_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_flows.start_flow_run.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_get_flow_run_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_flows.get_flow_run.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_cancel_flow_run_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_flows.cancel_flow_run.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_list_flow_runs_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_flows.list_flow_runs.asyncio_detailed"
+    )
+
+
+@pytest.mark.asyncio
+async def test_start_flow_success(mock_start_flow_run_asyncio, workflows_service):
+    mock_start_flow_run_asyncio.return_value = ok(new_flow_run(), status_code=202)
+
+    result = await workflows_service.start_flow(
+        "wf/flow", [42], idempotency_key="order-42"
+    )
+
+    assert result.id == "frn-test123"
+    body = mock_start_flow_run_asyncio.call_args.kwargs["body"]
+    assert body.to_dict() == {
+        "flow": "wf/flow",
+        "input": [42],
+        "idempotencyKey": "order-42",
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_flow_run_success(mock_get_flow_run_asyncio, workflows_service):
+    mock_get_flow_run_asyncio.return_value = ok(new_flow_run_details())
+
+    result = await workflows_service.get_flow_run("frn-test123")
+
+    assert result.id == "frn-test123"
+    mock_get_flow_run_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal, flow_run_id="frn-test123"
+    )
+
+
+@pytest.mark.asyncio
+async def test_cancel_flow_run_success(mock_cancel_flow_run_asyncio, workflows_service):
+    mock_cancel_flow_run_asyncio.return_value = ok(None, status_code=204)
+
+    await workflows_service.cancel_flow_run("frn-test123")
+
+    mock_cancel_flow_run_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal, flow_run_id="frn-test123"
+    )
+
+
+@pytest.mark.asyncio
+async def test_list_flow_runs_success(mock_list_flow_runs_asyncio, workflows_service):
+    mock_list_flow_runs_asyncio.return_value = ok(
+        [FlowRunWithCursor(flow_run=new_flow_run(), cursor="c1")]
+    )
+
+    result = await workflows_service.list_flow_runs(
+        ListFlowRunsParams(limit=5, status=["running"])
+    )
+
+    assert [r.flow_run.id for r in result] == ["frn-test123"]
+    mock_list_flow_runs_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal,
+        limit=5,
+        cursor=UNSET,
+        flow_slug=UNSET,
+        flow_id=UNSET,
+        status=[FlowRunStatus.RUNNING],
+        owner_id=UNSET,
+        workflow_version_id=UNSET,
+        workflow_id=UNSET,
+    )
+
+
+@pytest.mark.parametrize(
+    "endpoint,call,message",
+    [
+        (
+            "start_flow_run",
+            lambda svc: svc.start_flow("wf/flow", [42]),
+            "start flow run failed: nope",
+        ),
+        (
+            "get_flow_run",
+            lambda svc: svc.get_flow_run("frn-test123"),
+            "get flow run failed: nope",
+        ),
+        (
+            "cancel_flow_run",
+            lambda svc: svc.cancel_flow_run("frn-test123"),
+            "cancel flow run failed: nope",
+        ),
+        (
+            "list_flow_runs",
+            lambda svc: svc.list_flow_runs(),
+            "list flow runs failed: nope",
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_flow_run_api_errors(mocker, workflows_service, endpoint, call, message):
+    mocker.patch(
+        f"render.public_api.api.workflow_flows.{endpoint}.asyncio_detailed",
+        return_value=ok(Error(message="nope"), status_code=400),
+    )
+
+    with pytest.raises(ClientError, match=message):
+        await call(workflows_service)

{render-1.4.0 → render-1.6.0}/render/client/tests/test_method_parity.py

@@ -25,8 +25,15 @@ from render.experimental.object.client_sync import (
 )
 from render.experimental.sandbox.api import SandboxApi
 from render.experimental.sandbox.api_sync import SyncSandboxApi
-from render.experimental.sandbox.client import SandboxClient, SnapshotClient
+from render.experimental.sandbox.client import (
+    BuildClient,
+    ImageClient,
+    SandboxClient,
+    SnapshotClient,
+)
 from render.experimental.sandbox.client_sync import (
+    SyncBuildClient,
+    SyncImageClient,
     SyncSandboxClient,
     SyncSnapshotClient,
 )
@@ -42,6 +49,8 @@ ASYNC_SYNC_PAIRS = [
     (SandboxApi, SyncSandboxApi),
     (SandboxClient, SyncSandboxClient),
     (SnapshotClient, SyncSnapshotClient),
+    (ImageClient, SyncImageClient),
+    (BuildClient, SyncBuildClient),
 ]
 
 # Modules that contain async service classes. If you add a new module with

render-1.6.0/render/client/tests/test_requests.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Unit tests for the request builders shared by the workflows clients."""
+
+import pytest
+
+from render.client._requests import (
+    list_flow_runs_query,
+    run_task_body,
+    start_flow_run_body,
+)
+from render.client.types import ListFlowRunsParams
+from render.public_api.models.flow_run_status import FlowRunStatus
+from render.public_api.types import UNSET
+
+# Each case is (input_data, idempotency_key, expected "input"/"idempotencyKey"
+# fields of the serialized body). Tasks and flows share the cases so their
+# request bodies stay in step.
+_RUN_BODY_CASES = [
+    ([1, 2], None, {"input": [1, 2]}),
+    ({"a": 1}, None, {"input": {"a": 1}}),
+    ([1], "order-42", {"input": [1], "idempotencyKey": "order-42"}),
+]
+
+
+@pytest.mark.parametrize("input_data,idempotency_key,expected", _RUN_BODY_CASES)
+def test_run_task_body(input_data, idempotency_key, expected):
+    body = run_task_body("wf/task", input_data, idempotency_key)
+    assert body.to_dict() == {"task": "wf/task", **expected}
+
+
+@pytest.mark.parametrize("input_data,idempotency_key,expected", _RUN_BODY_CASES)
+def test_start_flow_run_body(input_data, idempotency_key, expected):
+    body = start_flow_run_body("wf/flow", input_data, idempotency_key)
+    assert body.to_dict() == {"flow": "wf/flow", **expected}
+
+
+_ALL_UNSET_QUERY = {
+    "limit": UNSET,
+    "cursor": UNSET,
+    "flow_slug": UNSET,
+    "flow_id": UNSET,
+    "status": UNSET,
+    "owner_id": UNSET,
+    "workflow_version_id": UNSET,
+    "workflow_id": UNSET,
+}
+
+
+@pytest.mark.parametrize(
+    "params,expected_overrides",
+    [
+        (None, {}),
+        (ListFlowRunsParams(), {}),
+        (ListFlowRunsParams(limit=5, cursor="c1"), {"limit": 5, "cursor": "c1"}),
+        (
+            ListFlowRunsParams(status=["running", FlowRunStatus.PAUSED]),
+            {"status": [FlowRunStatus.RUNNING, FlowRunStatus.PAUSED]},
+        ),
+        (
+            ListFlowRunsParams(
+                flow_slug=["wf/flow"],
+                flow_id=["flw-1"],
+                owner_id=["tea-1"],
+                workflow_version_id=["wfv-1"],
+                workflow_id=["wfl-1"],
+            ),
+            {
+                "flow_slug": ["wf/flow"],
+                "flow_id": ["flw-1"],
+                "owner_id": ["tea-1"],
+                "workflow_version_id": ["wfv-1"],
+                "workflow_id": ["wfl-1"],
+            },
+        ),
+    ],
+)
+def test_list_flow_runs_query(params, expected_overrides):
+    assert list_flow_runs_query(params) == {**_ALL_UNSET_QUERY, **expected_overrides}