render 1.0.1__tar.gz → 1.1.0__tar.gz

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

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.1.0] - 2026-09-10
+
+### Added
+
+- (Sandboxes) `sandboxes.list_groups()`, async and sync, returning a `SandboxGroupList` of `SandboxGroup` snapshots and an optional `next_cursor`. Alpha guarantees at most one group per workspace, so the page holds zero or one group
+- (Sandboxes) Sandbox snapshots through `sandboxes.snapshots`, with `create`, `from_id`, `list` and `delete`, async and sync
+- (Sandboxes) Snapshot `kind` in `snapshots.create()`: `filesystem` captures the writable filesystem, `runtime` also captures memory and CPU state; optional `expires_at`
+- (Sandboxes) `sandboxes.create()` accepts `snapshot_id` to start from a snapshot instead of the base image
+- (Sandboxes) Snapshot error types `SnapshotNotFoundError`, `SnapshotNotReadyError` and `SnapshotPlanMismatchError`, each exposing the API error `code` when the API sends one
+- (Key Value) The size-based plan names (`256mb`, `1g`, `5g`, `10g`, `20g`, `40g`) are accepted as `InstanceConfiguration.plan` for automatic provisioning
+- `ClientError.code` carries the API error code when the response includes one
+
+### Fixed
+
+- (Blueprints) `ResourceRefType.WORKFLOW`, so `BlueprintDetail.from_dict` parses a blueprint that declares workflows instead of raising `ValueError`
+
+### Changed
+
+- Regenerated the REST client from the latest OpenAPI schema: the new compute plan identifiers, sandbox execution listing and retrieval, service disk usage events, and env group linking against artifact sources
+
+## [1.0.1] - 2026-08-21
+
+### Changed
+
+- **Breaking** The package is now named `render` rather than `render_sdk`; install `render` and import `render`. `render_sdk` remains on PyPI as a shim that re-exports `render` at the same version and warns on import
+
 ## [1.0.0] - 2026-08-20
 
 ### Changed

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

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

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

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

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

@@ -33,7 +33,7 @@ Async REST API access:
     result = await task_run
 """
 
-__version__ = "1.0.1"
+__version__ = "1.1.0"
 
 # Render/RenderAsync are lazy-loaded so the workflow worker path stays fast.
 from typing import TYPE_CHECKING

{render-1.0.1 → render-1.1.0}/render/client/errors.py

@@ -6,9 +6,14 @@ class RenderError(Exception):
 
 class ClientError(RenderError):
     """Exception for client errors. This is returned when
-    the client makes a request to the API and the API returns a 4xx error."""
+    the client makes a request to the API and the API returns a 4xx error.
 
-    pass
+    code is the machine-readable code from the error body, or None when the
+    API did not send one."""
+
+    def __init__(self, *args: object, code: str | None = None) -> None:
+        super().__init__(*args)
+        self.code = code
 
 
 class RateLimitError(ClientError):

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

@@ -77,28 +77,28 @@ def workflows_service(client):
 @pytest.fixture
 def mock_cancel_task_run_asyncio(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.cancel_task_run.asyncio_detailed"
+        "render.public_api.api.workflow_tasks.cancel_task_run.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_list_task_runs_asyncio(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.list_task_runs.asyncio_detailed"
+        "render.public_api.api.workflow_tasks.list_task_runs.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_create_task_asyncio(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.create_task.asyncio_detailed"
+        "render.public_api.api.workflow_tasks.create_task.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_get_task_run_asyncio(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.get_task_run.asyncio_detailed"
+        "render.public_api.api.workflow_tasks.get_task_run.asyncio_detailed"
     )
 
 

{render-1.0.1 → render-1.1.0}/render/client/tests/test_method_parity.py

@@ -25,8 +25,11 @@ 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
-from render.experimental.sandbox.client_sync import SyncSandboxClient
+from render.experimental.sandbox.client import SandboxClient, SnapshotClient
+from render.experimental.sandbox.client_sync import (
+    SyncSandboxClient,
+    SyncSnapshotClient,
+)
 
 # All async/sync class pairs. Add new pairs here when creating a new service.
 ASYNC_SYNC_PAIRS = [
@@ -38,6 +41,7 @@ ASYNC_SYNC_PAIRS = [
     (ScopedObjectClient, SyncScopedObjectClient),
     (SandboxApi, SyncSandboxApi),
     (SandboxClient, SyncSandboxClient),
+    (SnapshotClient, SyncSnapshotClient),
 ]
 
 # Modules that contain async service classes. If you add a new module with

{render-1.0.1 → render-1.1.0}/render/client/tests/test_util.py

@@ -10,6 +10,7 @@ from render.client.util import (
     handle_http_error,
     handle_httpx_exception,
     handle_storage_http_error,
+    request_errors,
     retry_with_backoff,
 )
 from render.public_api.models.error import Error
@@ -159,6 +160,51 @@ def test_handle_api_error_extracts_message_from_content_when_parsed_is_none():
         handle_api_error(response, "API request")
 
 
+def test_handle_api_error_sets_code_from_parsed_error():
+    response = Response(
+        status_code=409,
+        content=b"",
+        headers={},
+        parsed=Error(message="sandbox is suspended", code="sandbox_not_running"),
+    )
+    with pytest.raises(ClientError, match="sandbox is suspended") as excinfo:
+        handle_api_error(response, "create snapshot")
+    assert excinfo.value.code == "sandbox_not_running"
+
+
+def test_handle_api_error_sets_code_from_content_when_parsed_is_none():
+    response = Response(
+        status_code=409,
+        content=b'{"message": "still creating", "code": "snapshot_creating"}',
+        headers={},
+        parsed=None,
+    )
+    with pytest.raises(ClientError) as excinfo:
+        handle_api_error(response, "delete snapshot")
+    assert excinfo.value.code == "snapshot_creating"
+
+
+def test_handle_api_error_code_is_none_when_absent():
+    response = Response(
+        status_code=400, content=b"", headers={}, parsed=Error(message="Bad request")
+    )
+    with pytest.raises(ClientError) as excinfo:
+        handle_api_error(response, "API request")
+    assert excinfo.value.code is None
+
+
+def test_handle_api_error_ignores_non_string_code_in_content():
+    response = Response(
+        status_code=409,
+        content=b'{"message": "still creating", "code": 409}',
+        headers={},
+        parsed=None,
+    )
+    with pytest.raises(ClientError) as excinfo:
+        handle_api_error(response, "delete snapshot")
+    assert excinfo.value.code is None
+
+
 def test_handle_api_error_fallback_when_content_is_not_json():
     """When parsed is None and content is not JSON, should use fallback message."""
     response = Response(
@@ -206,6 +252,32 @@ def test_handle_wrapper_exception_unexpected_error():
         _handle_wrapper_exception(exc, "op")
 
 
+def test_request_errors_passes_through_when_nothing_is_raised():
+    with request_errors("op"):
+        pass
+
+
+def test_request_errors_reraises_render_error():
+    with (
+        pytest.raises(ClientError, match="already a render error"),
+        request_errors("op"),
+    ):
+        raise ClientError("already a render error")
+
+
+def test_request_errors_translates_httpx_request_error():
+    with pytest.raises(TimeoutError, match="op timed out"), request_errors("op"):
+        raise httpx.TimeoutException("timed out")
+
+
+def test_request_errors_wraps_unexpected_error():
+    with (
+        pytest.raises(RenderError, match="failed with unexpected error: boom"),
+        request_errors("op"),
+    ):
+        raise ValueError("boom")
+
+
 class TestHandleStorageHttpError:
     """Tests for handle_storage_http_error function."""
 

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

@@ -77,28 +77,28 @@ def sync_workflows_service(client):
 @pytest.fixture
 def mock_cancel_task_run_sync(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.cancel_task_run.sync_detailed"
+        "render.public_api.api.workflow_tasks.cancel_task_run.sync_detailed"
     )
 
 
 @pytest.fixture
 def mock_list_task_runs_sync(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.list_task_runs.sync_detailed"
+        "render.public_api.api.workflow_tasks.list_task_runs.sync_detailed"
     )
 
 
 @pytest.fixture
 def mock_create_task_sync(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.create_task.sync_detailed"
+        "render.public_api.api.workflow_tasks.create_task.sync_detailed"
     )
 
 
 @pytest.fixture
 def mock_get_task_run_sync(mocker):
     return mocker.patch(
-        "render.public_api.api.workflow_tasks_beta.get_task_run.sync_detailed"
+        "render.public_api.api.workflow_tasks.get_task_run.sync_detailed"
     )
 
 

{render-1.0.1 → render-1.1.0}/render/client/util.py

@@ -4,7 +4,8 @@ import functools
 import json
 import logging
 from asyncio import sleep
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Generator
+from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any, NoReturn
 
 import httpx
@@ -194,6 +195,7 @@ def handle_api_error(
 
     message: str | None = None
     error_id: str | None = None
+    code: str | None = None
 
     # Try to extract error info from parsed response
     if isinstance(response.parsed, Error):
@@ -203,6 +205,9 @@ def handle_api_error(
         raw_id = getattr(response.parsed, "id", None)
         if raw_id is not None and not isinstance(raw_id, Unset):
             error_id = raw_id
+        raw_code = getattr(response.parsed, "code", None)
+        if raw_code is not None and not isinstance(raw_code, Unset):
+            code = raw_code
     elif response.parsed is None and response.content:
         # Parsed is None (e.g., 400 not handled) - try to extract from raw content
         try:
@@ -210,6 +215,8 @@ def handle_api_error(
             if isinstance(error_data, dict):
                 message = error_data.get("message")
                 error_id = error_data.get("id")
+                raw_code = error_data.get("code")
+                code = raw_code if isinstance(raw_code, str) else None
         except (json.JSONDecodeError, UnicodeDecodeError):
             pass
 
@@ -225,13 +232,13 @@ def handle_api_error(
 
     if response.status_code:
         if response.status_code == 429:
-            raise RateLimitError(full_message)
+            raise RateLimitError(full_message, code=code)
         if response.status_code >= 400 and response.status_code < 500:
-            raise ClientError(full_message)
+            raise ClientError(full_message, code=code)
         elif response.status_code >= 500:
             raise ServerError(full_message)
     else:
-        raise ClientError(full_message)
+        raise ClientError(full_message, code=code)
 
 
 def _handle_wrapper_exception(exc: Exception, operation: str) -> NoReturn:
@@ -252,6 +259,21 @@ def _handle_wrapper_exception(exc: Exception, operation: str) -> NoReturn:
     raise RenderError(f"{operation} failed with unexpected error: {exc}") from exc
 
 
+@contextmanager
+def request_errors(operation: str) -> Generator[None, None, None]:
+    """
+    Context manager form of handle_http_errors for a single request.
+
+    Translates HTTPX exceptions and non-JSON responses raised inside the block
+    into custom exceptions. Unlike the decorator, it leaves the HTTP status of
+    the response to the caller.
+    """
+    try:
+        yield
+    except Exception as exc:
+        _handle_wrapper_exception(exc, operation)
+
+
 def handle_http_errors(operation: str):
     """
     Decorator that handles HTTPX exceptions and HTTP error responses.

{render-1.0.1 → render-1.1.0}/render/client/util_sync.py

@@ -16,6 +16,7 @@ from render.client.util import (
     handle_http_error,
     handle_httpx_exception,
     handle_storage_http_error,
+    request_errors,
 )
 from render.public_api.models.error import Error
 from render.public_api.types import Response
@@ -28,6 +29,7 @@ __all__ = [
     "handle_api_error",
     "handle_http_error",
     "handle_httpx_exception",
+    "request_errors",
     "handle_storage_http_error",
 ]
 

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

@@ -24,13 +24,13 @@ from render.client.util import (
     handle_httpx_exception,
     retry_with_backoff,
 )
-from render.public_api.api.workflow_tasks_beta import (
+from render.public_api.api.workflow_tasks import (
     cancel_task_run,
     create_task,
     get_task_run,
     list_task_runs,
 )
-from render.public_api.api.workflow_tasks_beta.stream_task_runs_events import (
+from render.public_api.api.workflow_tasks.stream_task_runs_events import (
     _get_kwargs,
 )
 from render.public_api.models.error import Error

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

@@ -21,13 +21,13 @@ from render.client.types import (
 )
 from render.client.util import handle_http_error, handle_httpx_exception
 from render.client.util_sync import handle_http_errors, retry_with_backoff
-from render.public_api.api.workflow_tasks_beta import (
+from render.public_api.api.workflow_tasks import (
     cancel_task_run,
     create_task,
     get_task_run,
     list_task_runs,
 )
-from render.public_api.api.workflow_tasks_beta.stream_task_runs_events import (
+from render.public_api.api.workflow_tasks.stream_task_runs_events import (
     _get_kwargs,
 )
 from render.public_api.models.error import Error

render-1.1.0/render/experimental/key_value/tests/test_types.py

@@ -0,0 +1,25 @@
+"""Tests for the handwritten Key Value type aliases."""
+
+from typing import get_args
+
+from render.experimental.key_value.types import Plan
+from render.public_api.models.key_value_plan import KeyValuePlan
+
+# "custom" is a managed plan that cannot be requested when provisioning.
+UNPROVISIONABLE_PLANS = {"custom"}
+
+
+def test_plan_covers_every_provisionable_generated_plan():
+    """Plan is handwritten, so a schema-side plan addition can silently omit it.
+
+    Without this, a new plan name accepted by the API is rejected by mypy at
+    every InstanceConfiguration(plan=...) call site.
+    """
+    generated = {plan.value for plan in KeyValuePlan} - UNPROVISIONABLE_PLANS
+    assert set(get_args(Plan)) == generated
+
+
+def test_plan_values_construct_the_generated_enum():
+    """compare.py and provider.py pass a Plan straight to KeyValuePlan()."""
+    for value in get_args(Plan):
+        assert KeyValuePlan(value).value == value

{render-1.0.1 → render-1.1.0}/render/experimental/key_value/types.py

@@ -23,13 +23,20 @@ __all__ = [
     "ServiceIdOptions",
 ]
 
-# Excludes "custom", which is a managed plan not available for provisioning
+# Excludes "custom", which is a managed plan not available for provisioning.
+# tests/test_types.py asserts this stays in sync with the generated KeyValuePlan.
 Plan = Literal[
     "free",
     "starter",
     "standard",
     "pro",
     "pro_plus",
+    "256mb",
+    "1g",
+    "5g",
+    "10g",
+    "20g",
+    "40g",
 ]
 
 # Owner ID (format: "tea-xxx" for workspace teams, "own-xxx" for individuals)

{render-1.0.1 → render-1.1.0}/render/experimental/sandbox/__init__.py

@@ -1,19 +1,26 @@
 """Experimental sandbox client, accessed via ``render.experimental.sandboxes``."""
 
-from render.experimental.sandbox.client import SandboxClient
+from render.experimental.sandbox.client import SandboxClient, SnapshotClient
 from render.experimental.sandbox.errors import (
     SandboxDownloadError,
     SandboxExecError,
     SandboxExecStreamError,
     SandboxFileNotFoundError,
     SandboxNotFoundError,
+    SnapshotNotFoundError,
+    SnapshotNotReadyError,
+    SnapshotPlanMismatchError,
 )
 from render.experimental.sandbox.types import (
     Sandbox,
     SandboxExecEvent,
     SandboxExecExit,
     SandboxExecOutput,
+    SandboxGroup,
+    SandboxGroupList,
     SandboxList,
+    Snapshot,
+    SnapshotList,
 )
 
 __all__ = [
@@ -26,6 +33,14 @@ __all__ = [
     "SandboxExecOutput",
     "SandboxExecStreamError",
     "SandboxFileNotFoundError",
+    "SandboxGroup",
+    "SandboxGroupList",
     "SandboxList",
     "SandboxNotFoundError",
+    "Snapshot",
+    "SnapshotClient",
+    "SnapshotList",
+    "SnapshotNotFoundError",
+    "SnapshotNotReadyError",
+    "SnapshotPlanMismatchError",
 ]