render 1.4.0__tar.gz → 1.5.0__tar.gz

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

@@ -1,5 +1,23 @@
 # Changelog
 
+## [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.5.0}/PKG-INFO

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

{render-1.4.0 → render-1.5.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.5.0}/pyproject.toml

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

{render-1.4.0 → render-1.5.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.5.0"
 
 # Render/RenderAsync are lazy-loaded so the workflow worker path stays fast.
 from typing import TYPE_CHECKING

{render-1.4.0 → render-1.5.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.5.0}/render/client/tests/test_method_parity.py

@@ -25,8 +25,13 @@ 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,
+    SandboxClient,
+    SnapshotClient,
+)
 from render.experimental.sandbox.client_sync import (
+    SyncBuildClient,
     SyncSandboxClient,
     SyncSnapshotClient,
 )
@@ -42,6 +47,7 @@ ASYNC_SYNC_PAIRS = [
     (SandboxApi, SyncSandboxApi),
     (SandboxClient, SyncSandboxClient),
     (SnapshotClient, SyncSnapshotClient),
+    (BuildClient, SyncBuildClient),
 ]
 
 # Modules that contain async service classes. If you add a new module with

{render-1.4.0 → render-1.5.0}/render/experimental/experimental.py

@@ -9,7 +9,6 @@ from typing import TYPE_CHECKING
 from render.experimental.key_value.api import KeyValueApi
 from render.experimental.key_value.provider import KeyValueProvider
 from render.experimental.object.client import ObjectClient
-from render.experimental.sandbox.client import SandboxClient
 
 if TYPE_CHECKING:
     from render.client.client import Client
@@ -86,8 +85,3 @@ class ExperimentalService:
             KeyValueApi(client.internal),
             default_owner_id=client.owner_id,
         )
-        self.sandboxes = SandboxClient(
-            client.internal,
-            default_owner_id=client.owner_id,
-            default_region=client.region,
-        )

{render-1.4.0 → render-1.5.0}/render/experimental/experimental_sync.py

@@ -6,7 +6,6 @@ This module provides the sync versions of ExperimentalService and StorageService
 from typing import TYPE_CHECKING
 
 from render.experimental.object.client_sync import SyncObjectClient
-from render.experimental.sandbox.client_sync import SyncSandboxClient
 
 if TYPE_CHECKING:
     from render.client.client import Client
@@ -71,8 +70,3 @@ class SyncExperimentalService:
             client: The Render client instance
         """
         self.storage = SyncStorageService(client)
-        self.sandboxes = SyncSandboxClient(
-            client.internal,
-            default_owner_id=client.owner_id,
-            default_region=client.region,
-        )

{render-1.4.0 → render-1.5.0}/render/experimental/sandbox/__init__.py

@@ -1,19 +1,34 @@
-"""Experimental sandbox client, accessed via ``render.experimental.sandboxes``."""
+"""Sandbox client implementation, accessed via ``render.sandboxes``."""
 
-from render.experimental.sandbox.client import SandboxClient, SnapshotClient
+from render.experimental.sandbox.client import (
+    BuildClient,
+    SandboxClient,
+    SnapshotClient,
+)
 from render.experimental.sandbox.errors import (
+    BuildNotFoundError,
+    BuildNotReadyError,
+    SandboxCreateWaitError,
     SandboxDownloadError,
     SandboxExecError,
     SandboxExecStreamError,
     SandboxFileNotFoundError,
     SandboxNotFoundError,
+    SandboxNotRunningError,
+    SandboxWaitTimeoutError,
+    SnapshotCreateWaitError,
+    SnapshotFailedError,
     SnapshotNotFoundError,
     SnapshotNotReadyError,
     SnapshotPlanMismatchError,
+    SnapshotWaitTimeoutError,
 )
 from render.experimental.sandbox.types import (
+    Build,
+    BuildSource,
     EgressRule,
     NetworkPolicy,
+    RegistryCredential,
     Sandbox,
     SandboxExecEvent,
     SandboxExecExit,
@@ -21,15 +36,24 @@ from render.experimental.sandbox.types import (
     SandboxGroup,
     SandboxGroupList,
     SandboxList,
+    SandboxPlan,
+    SandboxWaitOptions,
     Snapshot,
     SnapshotList,
 )
 
 __all__ = [
+    "Build",
+    "BuildClient",
+    "BuildNotFoundError",
+    "BuildNotReadyError",
+    "BuildSource",
     "EgressRule",
     "NetworkPolicy",
+    "RegistryCredential",
     "Sandbox",
     "SandboxClient",
+    "SandboxCreateWaitError",
     "SandboxDownloadError",
     "SandboxExecError",
     "SandboxExecEvent",
@@ -41,10 +65,17 @@ __all__ = [
     "SandboxGroupList",
     "SandboxList",
     "SandboxNotFoundError",
+    "SandboxNotRunningError",
+    "SandboxPlan",
+    "SandboxWaitOptions",
+    "SandboxWaitTimeoutError",
     "Snapshot",
     "SnapshotClient",
+    "SnapshotCreateWaitError",
+    "SnapshotFailedError",
     "SnapshotList",
     "SnapshotNotFoundError",
     "SnapshotNotReadyError",
     "SnapshotPlanMismatchError",
+    "SnapshotWaitTimeoutError",
 ]

{render-1.4.0 → render-1.5.0}/render/experimental/sandbox/_tar.py

@@ -116,8 +116,8 @@ def _entry(tar: tarfile.TarFile, path: Path, arcname: str) -> tarfile.TarInfo |
     entry = tar.gettarinfo(str(path), arcname=arcname)
     if entry.islnk():
         # gettarinfo tracks inodes and emits a hardlink entry for the second and
-        # later names of a file. Go's tar.FileInfoHeader does not, so the CLI
-        # stores each name as its own regular file; match that.
+        # later names of a file. Store each name as its own regular file instead,
+        # so an extractor never has to resolve one entry against another.
         entry.type = tarfile.REGTYPE
         entry.linkname = ""
         entry.size = path.lstat().st_size

render-1.5.0/render/experimental/sandbox/_wait.py

@@ -0,0 +1,195 @@
+"""Polling a sandbox or snapshot until it is ready.
+
+The async and sync clients share this module, and unasync leaves it alone.
+apoll_until and poll_until live here for the same reason as
+files.arun_blocking: a transformed module can't hold both.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import math
+import time
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, NamedTuple, TypeVar
+
+from render.experimental.sandbox.errors import (
+    SandboxNotRunningError,
+    SnapshotFailedError,
+)
+
+if TYPE_CHECKING:
+    from render.experimental.sandbox.types import (
+        Sandbox,
+        SandboxWaitOptions,
+        Snapshot,
+    )
+
+# Matches the CLI's `sandboxes create --wait`.
+DEFAULT_SANDBOX_TIMEOUT_SECONDS = 60.0
+DEFAULT_SNAPSHOT_TIMEOUT_SECONDS = 300.0
+DEFAULT_INTERVAL_SECONDS = 0.25
+# The longest delay between checks once the backoff has grown.
+MAX_BACKOFF_INTERVAL_SECONDS = 2.0
+
+_T = TypeVar("_T")
+_R = TypeVar("_R")
+
+
+def monotonic() -> float:
+    return time.monotonic()
+
+
+async def asleep(seconds: float) -> None:
+    await asyncio.sleep(seconds)
+
+
+def sleep(seconds: float) -> None:
+    time.sleep(seconds)
+
+
+def validate(timeout_seconds: float, interval_seconds: float) -> None:
+    if not math.isfinite(timeout_seconds) or timeout_seconds < 0:
+        raise ValueError("timeout_seconds must be a finite number of at least 0")
+    if not math.isfinite(interval_seconds) or interval_seconds <= 0:
+        raise ValueError("interval_seconds must be a positive finite number")
+
+
+class WaitSettings(NamedTuple):
+    timeout_seconds: float
+    interval_seconds: float
+
+
+def resolve_create_wait(
+    wait: bool | SandboxWaitOptions, default_timeout_seconds: float
+) -> WaitSettings | None:
+    """Fill in the defaults for a create(wait=...), or return None if not waiting.
+
+    Raise ValueError for bad options. Call it before the create request, so bad
+    options create nothing.
+    """
+    if wait is False:
+        return None
+    timeout_seconds = default_timeout_seconds
+    interval_seconds = DEFAULT_INTERVAL_SECONDS
+    if wait is not True:
+        if wait.timeout_seconds is not None:
+            timeout_seconds = wait.timeout_seconds
+        interval_seconds = wait.interval_seconds
+    validate(timeout_seconds, interval_seconds)
+    return WaitSettings(timeout_seconds, interval_seconds)
+
+
+def running_sandbox(sandbox: Sandbox) -> Sandbox | None:
+    """Return the sandbox if it is running, or None if it may still get there.
+
+    Raise SandboxNotRunningError if it can't.
+    """
+    if sandbox.status == "running":
+        return sandbox
+    if sandbox.status in ("creating", "resuming"):
+        return None
+    raise SandboxNotRunningError(
+        f"sandbox {sandbox.id} is {sandbox.status}, not running",
+        sandbox_id=sandbox.id,
+        sandbox_status=sandbox.status,
+    )
+
+
+def available_snapshot(snapshot: Snapshot) -> Snapshot | None:
+    """Return the snapshot if it is available, or None if it is still creating.
+
+    Raise SnapshotFailedError if its capture failed.
+    """
+    if snapshot.status == "available":
+        return snapshot
+    if snapshot.status == "failed":
+        reason = f": {snapshot.error}" if snapshot.error else ""
+        raise SnapshotFailedError(
+            f"snapshot {snapshot.id} failed to capture{reason}",
+            snapshot_id=snapshot.id,
+            snapshot_error=snapshot.error,
+        )
+    return None
+
+
+class _Schedule:
+    """The deadline and backoff for one wait."""
+
+    def __init__(self, timeout_seconds: float, interval_seconds: float) -> None:
+        validate(timeout_seconds, interval_seconds)
+        self._deadline = monotonic() + timeout_seconds
+        self._interval = interval_seconds
+        self._max_interval = max(interval_seconds, MAX_BACKOFF_INTERVAL_SECONDS)
+
+    def remaining(self) -> float:
+        return self._deadline - monotonic()
+
+    def next_delay(self) -> float:
+        """Return the delay before the next check, and double the one after."""
+        delay = min(self._interval, max(self.remaining(), 0.0))
+        self._interval = min(self._interval * 2, self._max_interval)
+        return delay
+
+
+async def apoll_until(
+    load: Callable[[], Awaitable[_T]],
+    check: Callable[[_T], _R | None],
+    *,
+    timeout_seconds: float,
+    interval_seconds: float,
+    timeout_error: Callable[[_T | None], Exception],
+) -> _R:
+    """Call load until check returns a value, or raises because it never will.
+
+    The deadline also bounds each load, which is cancelled when it runs out.
+    """
+    schedule = _Schedule(timeout_seconds, interval_seconds)
+    last: _T | None = None
+    while True:
+        remaining = schedule.remaining()
+        if remaining <= 0:
+            raise timeout_error(last)
+        try:
+            value = await asyncio.wait_for(load(), remaining)
+        except asyncio.TimeoutError:
+            raise timeout_error(last) from None
+        last = value
+        # Check the status before the deadline, so a resource that is ready by
+        # the time a late check returns is returned, not discarded.
+        result = check(value)
+        if result is not None:
+            return result
+        if schedule.remaining() <= 0:
+            raise timeout_error(last)
+        await asleep(schedule.next_delay())
+
+
+def poll_until(
+    load: Callable[[], _T],
+    check: Callable[[_T], _R | None],
+    *,
+    timeout_seconds: float,
+    interval_seconds: float,
+    timeout_error: Callable[[_T | None], Exception],
+) -> _R:
+    """Call load until check returns a value, or raises because it never will.
+
+    A blocking load can't be cancelled, so one already running when the
+    deadline passes finishes first, within the HTTP client's own timeout.
+    """
+    schedule = _Schedule(timeout_seconds, interval_seconds)
+    last: _T | None = None
+    while True:
+        if schedule.remaining() <= 0:
+            raise timeout_error(last)
+        value = load()
+        last = value
+        # Check the status before the deadline, so a resource that is ready by
+        # the time a late check returns is returned, not discarded.
+        result = check(value)
+        if result is not None:
+            return result
+        if schedule.remaining() <= 0:
+            raise timeout_error(last)
+        sleep(schedule.next_delay())