runloop-api-client 0.60.0__tar.gz → 0.60.1__tar.gz

runloop_api_client-0.60.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.60.1"
+}

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.60.1 (2025-09-11)
+
+Full Changelog: [v0.60.0...v0.60.1](https://github.com/runloopai/api-client-python/compare/v0.60.0...v0.60.1)
+
 ## 0.60.0 (2025-09-10)
 
 Full Changelog: [v0.59.0...v0.60.0](https://github.com/runloopai/api-client-python/compare/v0.59.0...v0.60.0)

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: runloop_api_client
-Version: 0.60.0
+Version: 0.60.1
 Summary: The official Python library for the runloop API
 Project-URL: Homepage, https://github.com/runloopai/api-client-python
 Project-URL: Repository, https://github.com/runloopai/api-client-python
@@ -13,7 +13,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -21,13 +20,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: anyio<5,>=3.5.0
 Requires-Dist: distro<2,>=1.7.0
 Requires-Dist: httpx<1,>=0.23.0
-Requires-Dist: pydantic<3,>=1.9.0
+Requires-Dist: pydantic<2.11,>=1.9.0
 Requires-Dist: sniffio
 Requires-Dist: typing-extensions<5,>=4.10
+Requires-Dist: uuid-utils>=0.11.0
 Provides-Extra: aiohttp
 Requires-Dist: aiohttp; extra == 'aiohttp'
 Requires-Dist: httpx-aiohttp>=0.1.8; extra == 'aiohttp'
@@ -46,7 +46,7 @@ It is generated with [Stainless](https://www.stainless.com/).
 
 ## Documentation
 
-The REST API documentation can be found on [runloop.ai](https://runloop.ai). The full API of this library can be found in [api.md](https://github.com/runloopai/api-client-python/tree/main/api.md).
+The REST API documentation can be found on [runloop.ai](https://runloop.ai). The full API of this library can be found in [api.md](api.md).
 
 ## Installation
 
@@ -57,7 +57,7 @@ pip install runloop_api_client
 
 ## Usage
 
-The full API of this library can be found in [api.md](https://github.com/runloopai/api-client-python/tree/main/api.md).
+The full API of this library can be found in [api.md](api.md).
 
 ```python
 import os
@@ -325,7 +325,7 @@ client.with_options(timeout=5.0).devboxes.create()
 
 On timeout, an `APITimeoutError` is thrown.
 
-Note that requests that time out are [retried twice by default](https://github.com/runloopai/api-client-python/tree/main/#retries).
+Note that requests that time out are [retried twice by default](#retries).
 
 ## Advanced
 
@@ -493,4 +493,4 @@ Python 3.8 or higher.
 
 ## Contributing
 
-See [the contributing documentation](https://github.com/runloopai/api-client-python/tree/main/./CONTRIBUTING.md).
+See [the contributing documentation](./CONTRIBUTING.md).

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runloop_api_client"
-version = "0.60.0"
+version = "0.60.1"
 description = "The official Python library for the runloop API"
 dynamic = ["readme"]
 license = "MIT"
@@ -9,18 +9,18 @@ authors = [
 ]
 dependencies = [
     "httpx>=0.23.0, <1",
-    "pydantic>=1.9.0, <3",
+    "pydantic>=1.9.0, <2.11",
     "typing-extensions>=4.10, <5",
     "anyio>=3.5.0, <5",
     "distro>=1.7.0, <2",
     "sniffio",
+    "uuid-utils>=0.11.0",
 ]
 
-requires-python = ">= 3.8"
+requires-python = ">= 3.9"
 classifiers = [
   "Typing :: Typed",
   "Intended Audience :: Developers",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
@@ -59,6 +59,7 @@ dev-dependencies = [
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
     "pytest-xdist>=3.6.1",
+    "uuid-utils>=0.11.0"
 ]
 
 [tool.rye.scripts]
@@ -86,6 +87,7 @@ typecheck = { chain = [
   "typecheck:pyright",
   "typecheck:mypy"
 ]}
+
 "typecheck:pyright" = "pyright"
 "typecheck:verify-types" = "pyright --verifytypes runloop_api_client --ignoreexternal"
 "typecheck:mypy" = "mypy ."
@@ -130,8 +132,8 @@ path = "README.md"
 
 [[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
 # replace relative links with absolute links
-pattern = '\[(.+?)\]\(((?!https?://)\S+?)\)'
-replacement = '[\1](https://github.com/runloopai/api-client-python/tree/main/\g<2>)'
+pattern = '\\[(.+?)\\]\\(((?!https?://)\\S+?)\\)'
+replacement = '[\\1](https://github.com/runloopai/api-client-python/tree/main/\\g<2>)'
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
@@ -153,7 +155,7 @@ markers = [
 # there are a couple of flags that are still disabled by
 # default in strict mode as they are experimental and niche.
 typeCheckingMode = "strict"
-pythonVersion = "3.8"
+pythonVersion = "3.9"
 
 exclude = [
     "_dev",
@@ -223,7 +225,7 @@ ignore_missing_imports = true
 [tool.ruff]
 line-length = 120
 output-format = "grouped"
-target-version = "py38"
+target-version = "py39"
 
 [tool.ruff.format]
 docstring-code-format = true

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/requirements-dev.lock

@@ -97,10 +97,10 @@ pygments==2.18.0
 pyright==1.1.399
 pytest==8.3.3
     # via pytest-asyncio
+    # via pytest-timeout
     # via pytest-xdist
-pytest-timeout==2.3.1
-    # via runloop-api-client (dev)
 pytest-asyncio==0.24.0
+pytest-timeout==2.3.1
 pytest-xdist==3.7.0
 python-dateutil==2.8.2
     # via time-machine
@@ -128,6 +128,8 @@ typing-extensions==4.12.2
     # via pydantic-core
     # via pyright
     # via runloop-api-client
+uuid-utils==0.11.0
+    # via runloop-api-client
 virtualenv==20.24.5
     # via nox
 yarl==1.20.0

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/requirements.lock

@@ -68,5 +68,7 @@ typing-extensions==4.12.2
     # via pydantic
     # via pydantic-core
     # via runloop-api-client
+uuid-utils==0.11.0
+    # via runloop-api-client
 yarl==1.20.0
     # via aiohttp

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/src/runloop_api_client/_models.py

@@ -179,7 +179,7 @@ class BaseModel(pydantic.BaseModel):
     @classmethod
     @override
     def construct(  # pyright: ignore[reportIncompatibleMethodOverride]
-        __cls: Type[ModelT],
+        __cls: Type[ModelT], # type: ignore
         _fields_set: set[str] | None = None,
         **values: object,
     ) -> ModelT:

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/src/runloop_api_client/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "runloop_api_client"
-__version__ = "0.60.0"  # x-release-please-version
+__version__ = "0.60.1"  # x-release-please-version

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/src/runloop_api_client/resources/devboxes/devboxes.py

@@ -7,6 +7,9 @@ from typing_extensions import Literal
 
 import httpx
 
+# uuid_utils is not typed
+from uuid_utils import uuid7  # type: ignore
+
 from .lsp import (
     LspResource,
     AsyncLspResource,
@@ -787,6 +790,59 @@ class DevboxesResource(SyncAPIResource):
             cast_to=DevboxAsyncExecutionDetailView,
         )
 
+    def execute_and_await_completion(
+        self,
+        devbox_id: str,
+        *,
+        command: str,
+        shell_name: Optional[str] | NotGiven = NOT_GIVEN,
+        polling_config: PollingConfig | None = None,
+        # The following are forwarded to the initial execute request
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        idempotency_key: str | None = None,
+    ) -> DevboxAsyncExecutionDetailView:
+        """
+        Execute a command and wait for it to complete with optimal latency for long running commands.
+
+        This method launches an execution with a generated command_id and first attempts to
+        return the result within the initial request's timeout. If the execution is not yet
+        complete, it switches to using wait_for_command to minimize latency while waiting.
+        """
+        command_id = str(uuid7()) # type: ignore
+        execution = self.execute(
+            devbox_id,
+            command=command,
+            command_id=command_id,
+            shell_name=shell_name,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+            idempotency_key=idempotency_key,
+        )
+        if execution.status == "completed":
+            return execution
+
+        def handle_timeout_error(error: Exception) -> DevboxAsyncExecutionDetailView:
+            if isinstance(error, APITimeoutError) or (
+                isinstance(error, APIStatusError) and error.response.status_code == 408
+            ):
+                return execution
+            raise error
+
+        def is_done(result: DevboxAsyncExecutionDetailView) -> bool:
+            return result.status == "completed"
+
+        return poll_until(
+            lambda: self.wait_for_command(execution.execution_id, devbox_id=devbox_id, statuses=["completed"]),
+            is_done,
+            polling_config,
+            handle_timeout_error,
+        )
+
     def execute_async(
         self,
         id: str,
@@ -2175,6 +2231,60 @@ class AsyncDevboxesResource(AsyncAPIResource):
             cast_to=DevboxAsyncExecutionDetailView,
         )
 
+    async def execute_and_await_completion(
+        self,
+        devbox_id: str,
+        *,
+        command: str,
+        shell_name: Optional[str] | NotGiven = NOT_GIVEN,
+        polling_config: PollingConfig | None = None,
+        # The following are forwarded to the initial execute request
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+        idempotency_key: str | None = None,
+    ) -> DevboxAsyncExecutionDetailView:
+        """
+        Execute a command and wait for it to complete with optimal latency for long running commands.
+
+        This method launches an execution with a generated command_id and first attempts to
+        return the result within the initial request's timeout. If the execution is not yet
+        complete, it switches to using wait_for_command to minimize latency while waiting.
+        """
+
+        command_id = str(uuid7()) # type: ignore
+        execution = await self.execute(
+            devbox_id,
+            command=command,
+            command_id=command_id,
+            shell_name=shell_name,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+            idempotency_key=idempotency_key,
+        )
+        if execution.status == "completed":
+            return execution
+
+        def handle_timeout_error(error: Exception) -> DevboxAsyncExecutionDetailView:
+            if isinstance(error, APITimeoutError) or (
+                isinstance(error, APIStatusError) and error.response.status_code == 408
+            ):
+                return execution
+            raise error
+
+        def is_done(result: DevboxAsyncExecutionDetailView) -> bool:
+            return result.status == "completed"
+
+        return await async_poll_until(
+            lambda: self.wait_for_command(execution.execution_id, devbox_id=devbox_id, statuses=["completed"]),
+            is_done,
+            polling_config,
+            handle_timeout_error,
+        )
+
     async def execute_async(
         self,
         id: str,

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/tests/smoketests/README.md

@@ -1,6 +1,7 @@
 # Smoke tests
 
-End-to-end smoke tests run against the real API to validate critical flows (devboxes, snapshots, blueprints, executions/log tailing, scenarios/benchmarks).
+End-to-end smoke tests run against the real API to validate critical flows (devboxes, snapshots, blueprints, executions/log tailing, scenarios/benchmarks). Theses smoketests run both the 
+async and sync clients.
 
 - Local run (requires `RUNLOOP_API_KEY`):
 
@@ -13,13 +14,13 @@ export RUNLOOP_API_KEY=...  # required
 uv pip install -r requirements-dev.lock
 
 # Run all tests
-RUN_SMOKETESTS=1 uv run pytest -q -vv tests/smoketests
+RUN_SMOKETESTS=1 uv run pytest -q -vv -m smoketest tests/smoketests
 
 # Run a single file
-RUN_SMOKETESTS=1 uv run pytest -q -vv tests/smoketests/test_devboxes.py
+RUN_SMOKETESTS=1 uv run pytest -q -vv -m smoketest tests/smoketests/test_devboxes.py
 
 # Run a single test by name
-RUN_SMOKETESTS=1 uv run pytest -q -k "test_create_and_await_running_timeout" tests/smoketests/test_devboxes.py
+RUN_SMOKETESTS=1 uv run pytest -q -k -m smoketest "test_create_and_await_running_timeout" tests/smoketests/test_devboxes.py
 ```
 
 - GitHub Actions: add repo secret `RUNLOOP_SMOKETEST_DEV_API_KEY` and `RUNLOOP_SMOKETEST_PROD_API_KEY`. The workflow `.github/workflows/smoketests.yml` supports an input `environment` (dev|prod) and runs these tests in CI.

runloop_api_client-0.60.1/tests/smoketests/conftest.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+import pytest
+from _pytest.fixtures import FixtureRequest  # pyright: ignore[reportPrivateImportUsage]
+
+from runloop_api_client import Runloop
+
+from .utils import make_client, make_async_client_adapter
+
+"""
+This file is used to create a client fixture for the tests.
+It makes it possible to run the tests with both sync and async clients.
+"""
+
+
+@pytest.fixture(scope="module", params=["sync", "async"], ids=["sync-client", "async-client"])
+def client(request: FixtureRequest) -> Iterator[Runloop]:
+    if request.param == "sync":
+        c: Runloop = make_client()
+        try:
+            yield c
+        finally:
+            try:
+                # Runloop supports close()
+                c.close()
+            except Exception:
+                pass
+    else:
+        c: Runloop = make_async_client_adapter()
+        try:
+            yield c
+        finally:
+            try:
+                c.close()
+            except Exception:
+                pass

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/tests/smoketests/test_blueprints.py

@@ -1,13 +1,26 @@
+from __future__ import annotations
+
+from typing import Iterator
+
 import pytest
 
+from runloop_api_client import Runloop
 from runloop_api_client.lib.polling import PollingConfig
 
-from .utils import make_client, unique_name
+from .utils import unique_name
 
 pytestmark = [pytest.mark.smoketest]
 
 
-client = make_client()
+@pytest.fixture(autouse=True, scope="module")
+def _cleanup(client: Runloop) -> Iterator[None]:  # pyright: ignore[reportUnusedFunction]
+    yield
+    global _blueprint_id
+    if _blueprint_id:
+        try:
+            client.blueprints.delete(_blueprint_id)
+        except Exception:
+            pass
 
 
 """
@@ -18,17 +31,8 @@ _blueprint_id = None
 _blueprint_name = unique_name("bp")
 
 
-def teardown_module() -> None:
-    global _blueprint_id
-    if _blueprint_id:
-        try:
-            client.blueprints.delete(_blueprint_id)
-        except Exception:
-            pass
-
-
 @pytest.mark.timeout(30)
-def test_create_blueprint_and_await_build() -> None:
+def test_create_blueprint_and_await_build(client: Runloop) -> None:
     global _blueprint_id
     created = client.blueprints.create_and_await_build_complete(
         name=_blueprint_name,
@@ -39,7 +43,7 @@ def test_create_blueprint_and_await_build() -> None:
 
 
 @pytest.mark.timeout(30)
-def test_start_devbox_from_base_blueprint_by_id() -> None:
+def test_start_devbox_from_base_blueprint_by_id(client: Runloop) -> None:
     assert _blueprint_id
     devbox = client.devboxes.create_and_await_running(
         blueprint_id=_blueprint_id,
@@ -51,7 +55,7 @@ def test_start_devbox_from_base_blueprint_by_id() -> None:
 
 
 @pytest.mark.timeout(30)
-def test_start_devbox_from_base_blueprint_by_name() -> None:
+def test_start_devbox_from_base_blueprint_by_name(client: Runloop) -> None:
     devbox = client.devboxes.create_and_await_running(
         blueprint_name=_blueprint_name,
         polling_config=PollingConfig(max_attempts=120, interval_seconds=5.0, timeout_seconds=20 * 60),

{runloop_api_client-0.60.0 → runloop_api_client-0.60.1}/tests/smoketests/test_devboxes.py

@@ -1,13 +1,27 @@
+from __future__ import annotations
+
+from typing import Iterator
+
 import pytest
 
+from runloop_api_client import Runloop
 from runloop_api_client.lib.polling import PollingConfig, PollingTimeout
 
-from .utils import make_client, unique_name
+from .utils import unique_name
 
 pytestmark = [pytest.mark.smoketest]
 
 
-client = make_client()
+@pytest.fixture(autouse=True, scope="module")
+def _cleanup(client: Runloop) -> Iterator[None]:  # pyright: ignore[reportUnusedFunction]
+    yield
+    global _devbox_id
+    if _devbox_id:
+        try:
+            client.devboxes.shutdown(_devbox_id)
+        except Exception:
+            pass
+
 
 """
 Tests are run sequentially and can be dependent on each other. 
@@ -17,14 +31,14 @@ _devbox_id = None
 
 
 @pytest.mark.timeout(30)
-def test_create_devbox() -> None:
+def test_create_devbox(client: Runloop) -> None:
     created = client.devboxes.create(name=unique_name("smoke-devbox"))
     assert created.id
     client.devboxes.shutdown(created.id)
 
 
 @pytest.mark.timeout(30)
-def test_await_running_create_and_await_running() -> None:
+def test_await_running_create_and_await_running(client: Runloop) -> None:
     global _devbox_id
     created = client.devboxes.create_and_await_running(
         name=unique_name("smoketest-devbox2"),
@@ -34,19 +48,19 @@ def test_await_running_create_and_await_running() -> None:
     _devbox_id = created.id
 
 
-def test_list_devboxes() -> None:
+def test_list_devboxes(client: Runloop) -> None:
     page = client.devboxes.list(limit=10)
     assert isinstance(page.devboxes, list)
     assert len(page.devboxes) > 0
 
 
-def test_retrieve_devbox() -> None:
+def test_retrieve_devbox(client: Runloop) -> None:
     assert _devbox_id
     view = client.devboxes.retrieve(_devbox_id)
     assert view.id == _devbox_id
 
 
-def test_shutdown_devbox() -> None:
+def test_shutdown_devbox(client: Runloop) -> None:
     assert _devbox_id
     view = client.devboxes.shutdown(_devbox_id)
     assert view.id == _devbox_id
@@ -54,7 +68,7 @@ def test_shutdown_devbox() -> None:
 
 
 @pytest.mark.timeout(90)
-def test_create_and_await_running_long_set_up() -> None:
+def test_create_and_await_running_long_set_up(client: Runloop) -> None:
     created = client.devboxes.create_and_await_running(
         name=unique_name("smoketest-devbox-await-running-long-set-up"),
         launch_parameters={"launch_commands": ["sleep 70"]},
@@ -65,7 +79,7 @@ def test_create_and_await_running_long_set_up() -> None:
 
 
 @pytest.mark.timeout(30)
-def test_create_and_await_running_timeout() -> None:
+def test_create_and_await_running_timeout(client: Runloop) -> None:
     with pytest.raises(PollingTimeout):
         client.devboxes.create_and_await_running(
             name=unique_name("smoketest-devbox-await-running-timeout"),

runloop_api_client-0.60.1/tests/smoketests/test_executions.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+import pytest
+
+from runloop_api_client import Runloop
+from runloop_api_client.lib.polling import PollingConfig
+
+from .utils import unique_name
+
+pytestmark = [pytest.mark.smoketest]
+
+
+@pytest.fixture(autouse=True, scope="module")
+def _cleanup(client: Runloop) -> Iterator[None]:  # pyright: ignore[reportUnusedFunction]
+    yield
+    global _devbox_id
+    if _devbox_id:
+        try:
+            client.devboxes.shutdown(_devbox_id)
+        except Exception:
+            pass
+
+
+"""
+Tests are run sequentially and can be dependent on each other. 
+This is to avoid overloading resources and save efficiency.
+"""
+_devbox_id = None
+_exec_id = None
+
+
+@pytest.mark.timeout(30)
+def test_launch_devbox(client: Runloop) -> None:
+    global _devbox_id
+    created = client.devboxes.create_and_await_running(
+        name=unique_name("exec-devbox"),
+        polling_config=PollingConfig(max_attempts=120, interval_seconds=5.0, timeout_seconds=20 * 60),
+    )
+    _devbox_id = created.id
+
+
+@pytest.mark.timeout(30)
+def test_execute_async_and_await_completion(client: Runloop) -> None:
+    assert _devbox_id
+    global _exec_id
+    started = client.devboxes.executions.execute_async(_devbox_id, command="echo hello && sleep 1")
+    _exec_id = started.execution_id
+    completed = client.devboxes.executions.await_completed(
+        _exec_id,
+        devbox_id=_devbox_id,
+        polling_config=PollingConfig(max_attempts=120, interval_seconds=2.0, timeout_seconds=10 * 60),
+    )
+    assert completed.status == "completed"
+
+
+@pytest.mark.timeout(30)
+def test_tail_stdout_logs(client: Runloop) -> None:
+    assert _devbox_id and _exec_id
+    stream = client.devboxes.executions.stream_stdout_updates(execution_id=_exec_id, devbox_id=_devbox_id)
+    received = ""
+    for chunk in stream:
+        received += getattr(chunk, "output", "") or ""
+        if received:
+            break
+    assert isinstance(received, str)
+
+
+@pytest.mark.timeout(30)
+def test_execute_and_await_completion(client: Runloop) -> None:
+    assert _devbox_id
+    completed = client.devboxes.execute_and_await_completion(
+        _devbox_id,
+        command="echo hello && sleep 1",
+        polling_config=PollingConfig(max_attempts=120, interval_seconds=2.0, timeout_seconds=10 * 60),
+    )
+    assert completed.status == "completed"
+
+
+# @pytest.mark.timeout(90)
+# def test_execute_and_await_completion_long_running(client: Runloop) -> None:
+#     assert _devbox_id
+#     completed = client.devboxes.execute_and_await_completion(
+#         _devbox_id,
+#         command="echo hello && sleep 70",
+#         polling_config=PollingConfig(max_attempts=120, interval_seconds=2.0),
+#     )
+#     assert completed.status == "completed"
+
+
+# TODO: Uncomment this test when we fix timeouts for polling
+# @pytest.mark.timeout(30)
+# def test_execute_and_await_completion_timeout() -> None:
+#     assert _devbox_id
+#     with pytest.raises(PollingTimeout):
+#         client.devboxes.execute_and_await_completion(
+#             devbox_id=_devbox_id,
+#             command="echo hello && sleep 10",
+#             polling_config=PollingConfig(max_attempts=1, interval_seconds=2.0, timeout_seconds=3),
+#         )