From c4dbcf33822da8045def9617948e7b30f617fe51 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 17:45:14 +0000 Subject: [PATCH 1/4] feat(api): api update --- .stats.yml | 4 +- api.md | 1 + .../resources/devboxes/executions.py | 107 ++++++++++++++++ .../types/devboxes/__init__.py | 1 + .../devboxes/execution_send_std_in_params.py | 14 +++ .../api_resources/devboxes/test_executions.py | 114 ++++++++++++++++++ 6 files changed, 239 insertions(+), 2 deletions(-) create mode 100644 src/runloop_api_client/types/devboxes/execution_send_std_in_params.py diff --git a/.stats.yml b/.stats.yml index bd6f2f508..ed778ee7b 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 92 +configured_endpoints: 93 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-6b65a42b74406a77acb03ddb582288396d7af64df16eebf887c77246d3a54470.yml openapi_spec_hash: aeb9f595d53412926ef507174f33a1a1 -config_hash: f008c82c6ae5099c9a4b8e1fce1e15f1 +config_hash: 97c56b44c382faf3f8cbb0999532054f diff --git a/api.md b/api.md index d0fe270b3..e1146950f 100644 --- a/api.md +++ b/api.md @@ -198,6 +198,7 @@ Methods: - client.devboxes.executions.execute_async(id, \*\*params) -> DevboxAsyncExecutionDetailView - client.devboxes.executions.execute_sync(id, \*\*params) -> DevboxExecutionDetailView - client.devboxes.executions.kill(execution_id, \*, devbox_id, \*\*params) -> DevboxAsyncExecutionDetailView +- client.devboxes.executions.send_std_in(execution_id, \*, devbox_id, \*\*params) -> DevboxAsyncExecutionDetailView - client.devboxes.executions.stream_stderr_updates(execution_id, \*, devbox_id, \*\*params) -> ExecutionUpdateChunk - client.devboxes.executions.stream_stdout_updates(execution_id, \*, devbox_id, \*\*params) -> ExecutionUpdateChunk diff --git a/src/runloop_api_client/resources/devboxes/executions.py b/src/runloop_api_client/resources/devboxes/executions.py index d89018ca3..7d9906559 100755 --- a/src/runloop_api_client/resources/devboxes/executions.py +++ b/src/runloop_api_client/resources/devboxes/executions.py @@ -25,6 +25,7 @@ from ...types.devboxes import ( execution_kill_params, execution_retrieve_params, + execution_send_std_in_params, execution_execute_sync_params, execution_execute_async_params, execution_stream_stderr_updates_params, @@ -332,6 +333,53 @@ def kill( cast_to=DevboxAsyncExecutionDetailView, ) + def send_std_in( + self, + execution_id: str, + *, + devbox_id: str, + text: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + 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: + """ + Send content to the Std In of a running execution. + + Args: + text: Text to send to std in of the running execution. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not devbox_id: + raise ValueError(f"Expected a non-empty value for `devbox_id` but received {devbox_id!r}") + if not execution_id: + raise ValueError(f"Expected a non-empty value for `execution_id` but received {execution_id!r}") + return self._post( + f"/v1/devboxes/{devbox_id}/executions/{execution_id}/send_std_in", + body=maybe_transform({"text": text}, execution_send_std_in_params.ExecutionSendStdInParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=DevboxAsyncExecutionDetailView, + ) + def stream_stderr_updates( self, execution_id: str, @@ -785,6 +833,53 @@ async def kill( cast_to=DevboxAsyncExecutionDetailView, ) + async def send_std_in( + self, + execution_id: str, + *, + devbox_id: str, + text: str | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + 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: + """ + Send content to the Std In of a running execution. + + Args: + text: Text to send to std in of the running execution. + + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not devbox_id: + raise ValueError(f"Expected a non-empty value for `devbox_id` but received {devbox_id!r}") + if not execution_id: + raise ValueError(f"Expected a non-empty value for `execution_id` but received {execution_id!r}") + return await self._post( + f"/v1/devboxes/{devbox_id}/executions/{execution_id}/send_std_in", + body=await async_maybe_transform({"text": text}, execution_send_std_in_params.ExecutionSendStdInParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=DevboxAsyncExecutionDetailView, + ) + async def stream_stderr_updates( self, execution_id: str, @@ -973,6 +1068,9 @@ def __init__(self, executions: ExecutionsResource) -> None: self.kill = to_raw_response_wrapper( executions.kill, ) + self.send_std_in = to_raw_response_wrapper( + executions.send_std_in, + ) self.stream_stdout_updates = to_raw_response_wrapper( executions.stream_stdout_updates, ) @@ -999,6 +1097,9 @@ def __init__(self, executions: AsyncExecutionsResource) -> None: self.kill = async_to_raw_response_wrapper( executions.kill, ) + self.send_std_in = async_to_raw_response_wrapper( + executions.send_std_in, + ) self.stream_stdout_updates = async_to_raw_response_wrapper( executions.stream_stdout_updates, ) @@ -1025,6 +1126,9 @@ def __init__(self, executions: ExecutionsResource) -> None: self.kill = to_streamed_response_wrapper( executions.kill, ) + self.send_std_in = to_streamed_response_wrapper( + executions.send_std_in, + ) self.stream_stdout_updates = to_streamed_response_wrapper( executions.stream_stdout_updates, ) @@ -1051,6 +1155,9 @@ def __init__(self, executions: AsyncExecutionsResource) -> None: self.kill = async_to_streamed_response_wrapper( executions.kill, ) + self.send_std_in = async_to_streamed_response_wrapper( + executions.send_std_in, + ) self.stream_stdout_updates = async_to_streamed_response_wrapper( executions.stream_stdout_updates, ) diff --git a/src/runloop_api_client/types/devboxes/__init__.py b/src/runloop_api_client/types/devboxes/__init__.py index 9b7f0134d..0852b4c30 100644 --- a/src/runloop_api_client/types/devboxes/__init__.py +++ b/src/runloop_api_client/types/devboxes/__init__.py @@ -13,6 +13,7 @@ from .disk_snapshot_list_params import DiskSnapshotListParams as DiskSnapshotListParams from .execution_retrieve_params import ExecutionRetrieveParams as ExecutionRetrieveParams from .disk_snapshot_update_params import DiskSnapshotUpdateParams as DiskSnapshotUpdateParams +from .execution_send_std_in_params import ExecutionSendStdInParams as ExecutionSendStdInParams from .execution_execute_sync_params import ExecutionExecuteSyncParams as ExecutionExecuteSyncParams from .execution_execute_async_params import ExecutionExecuteAsyncParams as ExecutionExecuteAsyncParams from .computer_mouse_interaction_params import ComputerMouseInteractionParams as ComputerMouseInteractionParams diff --git a/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py b/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py new file mode 100644 index 000000000..df6dfe672 --- /dev/null +++ b/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py @@ -0,0 +1,14 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["ExecutionSendStdInParams"] + + +class ExecutionSendStdInParams(TypedDict, total=False): + devbox_id: Required[str] + + text: str + """Text to send to std in of the running execution.""" diff --git a/tests/api_resources/devboxes/test_executions.py b/tests/api_resources/devboxes/test_executions.py index e91eae41d..33e1a8c33 100755 --- a/tests/api_resources/devboxes/test_executions.py +++ b/tests/api_resources/devboxes/test_executions.py @@ -247,6 +247,63 @@ def test_path_params_kill(self, client: Runloop) -> None: devbox_id="devbox_id", ) + @parametrize + def test_method_send_std_in(self, client: Runloop) -> None: + execution = client.devboxes.executions.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + def test_method_send_std_in_with_all_params(self, client: Runloop) -> None: + execution = client.devboxes.executions.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + text="text", + ) + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + def test_raw_response_send_std_in(self, client: Runloop) -> None: + response = client.devboxes.executions.with_raw_response.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + execution = response.parse() + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + def test_streaming_response_send_std_in(self, client: Runloop) -> None: + with client.devboxes.executions.with_streaming_response.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + execution = response.parse() + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_send_std_in(self, client: Runloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `devbox_id` but received ''"): + client.devboxes.executions.with_raw_response.send_std_in( + execution_id="execution_id", + devbox_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `execution_id` but received ''"): + client.devboxes.executions.with_raw_response.send_std_in( + execution_id="", + devbox_id="devbox_id", + ) + @parametrize def test_method_stream_stdout_updates(self, client: Runloop, respx_mock: MockRouter) -> None: respx_mock.get("/v1/devboxes/devbox_id/executions/execution_id/stream_stdout_updates").mock( @@ -770,6 +827,63 @@ async def test_path_params_kill(self, async_client: AsyncRunloop) -> None: devbox_id="devbox_id", ) + @parametrize + async def test_method_send_std_in(self, async_client: AsyncRunloop) -> None: + execution = await async_client.devboxes.executions.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + async def test_method_send_std_in_with_all_params(self, async_client: AsyncRunloop) -> None: + execution = await async_client.devboxes.executions.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + text="text", + ) + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + async def test_raw_response_send_std_in(self, async_client: AsyncRunloop) -> None: + response = await async_client.devboxes.executions.with_raw_response.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + execution = await response.parse() + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + @parametrize + async def test_streaming_response_send_std_in(self, async_client: AsyncRunloop) -> None: + async with async_client.devboxes.executions.with_streaming_response.send_std_in( + execution_id="execution_id", + devbox_id="devbox_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + execution = await response.parse() + assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_send_std_in(self, async_client: AsyncRunloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `devbox_id` but received ''"): + await async_client.devboxes.executions.with_raw_response.send_std_in( + execution_id="execution_id", + devbox_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `execution_id` but received ''"): + await async_client.devboxes.executions.with_raw_response.send_std_in( + execution_id="", + devbox_id="devbox_id", + ) + @parametrize async def test_method_stream_stdout_updates(self, async_client: AsyncRunloop, respx_mock: MockRouter) -> None: respx_mock.get("/v1/devboxes/devbox_id/executions/execution_id/stream_stdout_updates").mock( From 736c122c5a350ba081eb495786e94ad6b999b121 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 19:06:32 +0000 Subject: [PATCH 2/4] feat(api): api update --- .stats.yml | 8 +- api.md | 1 + .../resources/repositories.py | 105 +++++++++++- tests/api_resources/test_repositories.py | 160 ++++++++++++++---- 4 files changed, 228 insertions(+), 46 deletions(-) diff --git a/.stats.yml b/.stats.yml index ed778ee7b..99d659dd3 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 93 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-6b65a42b74406a77acb03ddb582288396d7af64df16eebf887c77246d3a54470.yml -openapi_spec_hash: aeb9f595d53412926ef507174f33a1a1 -config_hash: 97c56b44c382faf3f8cbb0999532054f +configured_endpoints: 94 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-6bdf8a52fe1e6d7564c6cc54b3743ea05ea324a9420808764b17d02483dbaf86.yml +openapi_spec_hash: 23c253ceed235b9f13794beb091941c8 +config_hash: 82af97d4d6dde958eed9f5e4ae55f75a diff --git a/api.md b/api.md index e1146950f..245907bbc 100644 --- a/api.md +++ b/api.md @@ -313,6 +313,7 @@ Methods: - client.repositories.inspect(id, \*\*params) -> RepositoryInspectionDetails - client.repositories.list_inspections(id) -> RepositoryInspectionListView - client.repositories.refresh(id, \*\*params) -> object +- client.repositories.retrieve_inspection(id) -> RepositoryInspectionDetails # Secrets diff --git a/src/runloop_api_client/resources/repositories.py b/src/runloop_api_client/resources/repositories.py index 49e3fb9a2..e2b238750 100644 --- a/src/runloop_api_client/resources/repositories.py +++ b/src/runloop_api_client/resources/repositories.py @@ -2,6 +2,7 @@ from __future__ import annotations +import typing_extensions from typing import Optional import httpx @@ -321,6 +322,7 @@ def list_inspections( cast_to=RepositoryInspectionListView, ) + @typing_extensions.deprecated("deprecated") def refresh( self, id: str, @@ -375,6 +377,39 @@ def refresh( cast_to=object, ) + def retrieve_inspection( + self, + id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> RepositoryInspectionDetails: + """ + Get a repository inspection by id. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return self._get( + f"/v1/repositories/inspections/{id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=RepositoryInspectionDetails, + ) + class AsyncRepositoriesResource(AsyncAPIResource): @cached_property @@ -666,6 +701,7 @@ async def list_inspections( cast_to=RepositoryInspectionListView, ) + @typing_extensions.deprecated("deprecated") async def refresh( self, id: str, @@ -720,6 +756,39 @@ async def refresh( cast_to=object, ) + async def retrieve_inspection( + self, + id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> RepositoryInspectionDetails: + """ + Get a repository inspection by id. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return await self._get( + f"/v1/repositories/inspections/{id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=RepositoryInspectionDetails, + ) + class RepositoriesResourceWithRawResponse: def __init__(self, repositories: RepositoriesResource) -> None: @@ -743,8 +812,13 @@ def __init__(self, repositories: RepositoriesResource) -> None: self.list_inspections = to_raw_response_wrapper( repositories.list_inspections, ) - self.refresh = to_raw_response_wrapper( - repositories.refresh, + self.refresh = ( # pyright: ignore[reportDeprecated] + to_raw_response_wrapper( + repositories.refresh, # pyright: ignore[reportDeprecated], + ) + ) + self.retrieve_inspection = to_raw_response_wrapper( + repositories.retrieve_inspection, ) @@ -770,8 +844,13 @@ def __init__(self, repositories: AsyncRepositoriesResource) -> None: self.list_inspections = async_to_raw_response_wrapper( repositories.list_inspections, ) - self.refresh = async_to_raw_response_wrapper( - repositories.refresh, + self.refresh = ( # pyright: ignore[reportDeprecated] + async_to_raw_response_wrapper( + repositories.refresh, # pyright: ignore[reportDeprecated], + ) + ) + self.retrieve_inspection = async_to_raw_response_wrapper( + repositories.retrieve_inspection, ) @@ -797,8 +876,13 @@ def __init__(self, repositories: RepositoriesResource) -> None: self.list_inspections = to_streamed_response_wrapper( repositories.list_inspections, ) - self.refresh = to_streamed_response_wrapper( - repositories.refresh, + self.refresh = ( # pyright: ignore[reportDeprecated] + to_streamed_response_wrapper( + repositories.refresh, # pyright: ignore[reportDeprecated], + ) + ) + self.retrieve_inspection = to_streamed_response_wrapper( + repositories.retrieve_inspection, ) @@ -824,6 +908,11 @@ def __init__(self, repositories: AsyncRepositoriesResource) -> None: self.list_inspections = async_to_streamed_response_wrapper( repositories.list_inspections, ) - self.refresh = async_to_streamed_response_wrapper( - repositories.refresh, + self.refresh = ( # pyright: ignore[reportDeprecated] + async_to_streamed_response_wrapper( + repositories.refresh, # pyright: ignore[reportDeprecated], + ) + ) + self.retrieve_inspection = async_to_streamed_response_wrapper( + repositories.retrieve_inspection, ) diff --git a/tests/api_resources/test_repositories.py b/tests/api_resources/test_repositories.py index c07d16b35..282688d80 100644 --- a/tests/api_resources/test_repositories.py +++ b/tests/api_resources/test_repositories.py @@ -16,6 +16,8 @@ ) from runloop_api_client.pagination import SyncRepositoriesCursorIDPage, AsyncRepositoriesCursorIDPage +# pyright: reportDeprecated=false + base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -263,25 +265,30 @@ def test_path_params_list_inspections(self, client: Runloop) -> None: @parametrize def test_method_refresh(self, client: Runloop) -> None: - repository = client.repositories.refresh( - id="id", - ) + with pytest.warns(DeprecationWarning): + repository = client.repositories.refresh( + id="id", + ) + assert_matches_type(object, repository, path=["response"]) @parametrize def test_method_refresh_with_all_params(self, client: Runloop) -> None: - repository = client.repositories.refresh( - id="id", - blueprint_id="blueprint_id", - github_auth_token="github_auth_token", - ) + with pytest.warns(DeprecationWarning): + repository = client.repositories.refresh( + id="id", + blueprint_id="blueprint_id", + github_auth_token="github_auth_token", + ) + assert_matches_type(object, repository, path=["response"]) @parametrize def test_raw_response_refresh(self, client: Runloop) -> None: - response = client.repositories.with_raw_response.refresh( - id="id", - ) + with pytest.warns(DeprecationWarning): + response = client.repositories.with_raw_response.refresh( + id="id", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -290,22 +297,62 @@ def test_raw_response_refresh(self, client: Runloop) -> None: @parametrize def test_streaming_response_refresh(self, client: Runloop) -> None: - with client.repositories.with_streaming_response.refresh( - id="id", + with pytest.warns(DeprecationWarning): + with client.repositories.with_streaming_response.refresh( + id="id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + repository = response.parse() + assert_matches_type(object, repository, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_refresh(self, client: Runloop) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.repositories.with_raw_response.refresh( + id="", + ) + + @parametrize + def test_method_retrieve_inspection(self, client: Runloop) -> None: + repository = client.repositories.retrieve_inspection( + "id", + ) + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) + + @parametrize + def test_raw_response_retrieve_inspection(self, client: Runloop) -> None: + response = client.repositories.with_raw_response.retrieve_inspection( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + repository = response.parse() + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) + + @parametrize + def test_streaming_response_retrieve_inspection(self, client: Runloop) -> None: + with client.repositories.with_streaming_response.retrieve_inspection( + "id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" repository = response.parse() - assert_matches_type(object, repository, path=["response"]) + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize - def test_path_params_refresh(self, client: Runloop) -> None: + def test_path_params_retrieve_inspection(self, client: Runloop) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - client.repositories.with_raw_response.refresh( - id="", + client.repositories.with_raw_response.retrieve_inspection( + "", ) @@ -555,25 +602,30 @@ async def test_path_params_list_inspections(self, async_client: AsyncRunloop) -> @parametrize async def test_method_refresh(self, async_client: AsyncRunloop) -> None: - repository = await async_client.repositories.refresh( - id="id", - ) + with pytest.warns(DeprecationWarning): + repository = await async_client.repositories.refresh( + id="id", + ) + assert_matches_type(object, repository, path=["response"]) @parametrize async def test_method_refresh_with_all_params(self, async_client: AsyncRunloop) -> None: - repository = await async_client.repositories.refresh( - id="id", - blueprint_id="blueprint_id", - github_auth_token="github_auth_token", - ) + with pytest.warns(DeprecationWarning): + repository = await async_client.repositories.refresh( + id="id", + blueprint_id="blueprint_id", + github_auth_token="github_auth_token", + ) + assert_matches_type(object, repository, path=["response"]) @parametrize async def test_raw_response_refresh(self, async_client: AsyncRunloop) -> None: - response = await async_client.repositories.with_raw_response.refresh( - id="id", - ) + with pytest.warns(DeprecationWarning): + response = await async_client.repositories.with_raw_response.refresh( + id="id", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -582,20 +634,60 @@ async def test_raw_response_refresh(self, async_client: AsyncRunloop) -> None: @parametrize async def test_streaming_response_refresh(self, async_client: AsyncRunloop) -> None: - async with async_client.repositories.with_streaming_response.refresh( - id="id", + with pytest.warns(DeprecationWarning): + async with async_client.repositories.with_streaming_response.refresh( + id="id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + repository = await response.parse() + assert_matches_type(object, repository, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_refresh(self, async_client: AsyncRunloop) -> None: + with pytest.warns(DeprecationWarning): + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.repositories.with_raw_response.refresh( + id="", + ) + + @parametrize + async def test_method_retrieve_inspection(self, async_client: AsyncRunloop) -> None: + repository = await async_client.repositories.retrieve_inspection( + "id", + ) + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) + + @parametrize + async def test_raw_response_retrieve_inspection(self, async_client: AsyncRunloop) -> None: + response = await async_client.repositories.with_raw_response.retrieve_inspection( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + repository = await response.parse() + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve_inspection(self, async_client: AsyncRunloop) -> None: + async with async_client.repositories.with_streaming_response.retrieve_inspection( + "id", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" repository = await response.parse() - assert_matches_type(object, repository, path=["response"]) + assert_matches_type(RepositoryInspectionDetails, repository, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize - async def test_path_params_refresh(self, async_client: AsyncRunloop) -> None: + async def test_path_params_retrieve_inspection(self, async_client: AsyncRunloop) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): - await async_client.repositories.with_raw_response.refresh( - id="", + await async_client.repositories.with_raw_response.retrieve_inspection( + "", ) From b13e49f006c45d3e10c0383825fbe2054b31b351 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 3 Oct 2025 20:34:11 +0000 Subject: [PATCH 3/4] feat(api): api update --- .stats.yml | 4 +-- .../resources/devboxes/executions.py | 27 ++++++++++++++++--- .../devboxes/execution_send_std_in_params.py | 8 ++++-- .../api_resources/devboxes/test_executions.py | 2 ++ 4 files changed, 33 insertions(+), 8 deletions(-) diff --git a/.stats.yml b/.stats.yml index 99d659dd3..3999b4279 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 94 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-6bdf8a52fe1e6d7564c6cc54b3743ea05ea324a9420808764b17d02483dbaf86.yml -openapi_spec_hash: 23c253ceed235b9f13794beb091941c8 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-d1cc15eb5ef9125c6eef2855fc9ccc1129f68116e20ac0a72a9c77a445909033.yml +openapi_spec_hash: 925f218d18ed7f1faff9389b318a674f config_hash: 82af97d4d6dde958eed9f5e4ae55f75a diff --git a/src/runloop_api_client/resources/devboxes/executions.py b/src/runloop_api_client/resources/devboxes/executions.py index 7d9906559..6f4189c96 100755 --- a/src/runloop_api_client/resources/devboxes/executions.py +++ b/src/runloop_api_client/resources/devboxes/executions.py @@ -4,6 +4,7 @@ import typing_extensions from typing import Optional, cast +from typing_extensions import Literal import httpx @@ -338,7 +339,8 @@ def send_std_in( execution_id: str, *, devbox_id: str, - text: str | Omit = omit, + signal: Optional[Literal["EOF", "INTERRUPT"]] | Omit = omit, + text: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. extra_headers: Headers | None = None, @@ -351,6 +353,8 @@ def send_std_in( Send content to the Std In of a running execution. Args: + signal: Signal to send to std in of the running execution. + text: Text to send to std in of the running execution. extra_headers: Send extra headers @@ -369,7 +373,13 @@ def send_std_in( raise ValueError(f"Expected a non-empty value for `execution_id` but received {execution_id!r}") return self._post( f"/v1/devboxes/{devbox_id}/executions/{execution_id}/send_std_in", - body=maybe_transform({"text": text}, execution_send_std_in_params.ExecutionSendStdInParams), + body=maybe_transform( + { + "signal": signal, + "text": text, + }, + execution_send_std_in_params.ExecutionSendStdInParams, + ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, @@ -838,7 +848,8 @@ async def send_std_in( execution_id: str, *, devbox_id: str, - text: str | Omit = omit, + signal: Optional[Literal["EOF", "INTERRUPT"]] | Omit = omit, + text: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. extra_headers: Headers | None = None, @@ -851,6 +862,8 @@ async def send_std_in( Send content to the Std In of a running execution. Args: + signal: Signal to send to std in of the running execution. + text: Text to send to std in of the running execution. extra_headers: Send extra headers @@ -869,7 +882,13 @@ async def send_std_in( raise ValueError(f"Expected a non-empty value for `execution_id` but received {execution_id!r}") return await self._post( f"/v1/devboxes/{devbox_id}/executions/{execution_id}/send_std_in", - body=await async_maybe_transform({"text": text}, execution_send_std_in_params.ExecutionSendStdInParams), + body=await async_maybe_transform( + { + "signal": signal, + "text": text, + }, + execution_send_std_in_params.ExecutionSendStdInParams, + ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, diff --git a/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py b/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py index df6dfe672..0d8358958 100644 --- a/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py +++ b/src/runloop_api_client/types/devboxes/execution_send_std_in_params.py @@ -2,7 +2,8 @@ from __future__ import annotations -from typing_extensions import Required, TypedDict +from typing import Optional +from typing_extensions import Literal, Required, TypedDict __all__ = ["ExecutionSendStdInParams"] @@ -10,5 +11,8 @@ class ExecutionSendStdInParams(TypedDict, total=False): devbox_id: Required[str] - text: str + signal: Optional[Literal["EOF", "INTERRUPT"]] + """Signal to send to std in of the running execution.""" + + text: Optional[str] """Text to send to std in of the running execution.""" diff --git a/tests/api_resources/devboxes/test_executions.py b/tests/api_resources/devboxes/test_executions.py index 33e1a8c33..a3bcaaa1e 100755 --- a/tests/api_resources/devboxes/test_executions.py +++ b/tests/api_resources/devboxes/test_executions.py @@ -260,6 +260,7 @@ def test_method_send_std_in_with_all_params(self, client: Runloop) -> None: execution = client.devboxes.executions.send_std_in( execution_id="execution_id", devbox_id="devbox_id", + signal="EOF", text="text", ) assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) @@ -840,6 +841,7 @@ async def test_method_send_std_in_with_all_params(self, async_client: AsyncRunlo execution = await async_client.devboxes.executions.send_std_in( execution_id="execution_id", devbox_id="devbox_id", + signal="EOF", text="text", ) assert_matches_type(DevboxAsyncExecutionDetailView, execution, path=["response"]) From a2666626f4b2eb093571ee6c72a2cb80e348d10c Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 6 Oct 2025 22:54:38 +0000 Subject: [PATCH 4/4] release: 0.64.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 10 ++++++++++ pyproject.toml | 2 +- src/runloop_api_client/_version.py | 2 +- 4 files changed, 13 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3cb6257ce..4c56f2a48 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.63.0" + ".": "0.64.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 7ba984a0b..9e01527ba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,15 @@ # Changelog +## 0.64.0 (2025-10-06) + +Full Changelog: [v0.63.0...v0.64.0](https://github.com/runloopai/api-client-python/compare/v0.63.0...v0.64.0) + +### Features + +* **api:** api update ([b13e49f](https://github.com/runloopai/api-client-python/commit/b13e49f006c45d3e10c0383825fbe2054b31b351)) +* **api:** api update ([736c122](https://github.com/runloopai/api-client-python/commit/736c122c5a350ba081eb495786e94ad6b999b121)) +* **api:** api update ([c4dbcf3](https://github.com/runloopai/api-client-python/commit/c4dbcf33822da8045def9617948e7b30f617fe51)) + ## 0.63.0 (2025-10-02) Full Changelog: [v0.62.0...v0.63.0](https://github.com/runloopai/api-client-python/compare/v0.62.0...v0.63.0) diff --git a/pyproject.toml b/pyproject.toml index 0aafc3020..d43a7d9e1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "runloop_api_client" -version = "0.63.0" +version = "0.64.0" description = "The official Python library for the runloop API" dynamic = ["readme"] license = "MIT" diff --git a/src/runloop_api_client/_version.py b/src/runloop_api_client/_version.py index 5c8f372d6..86a8c7253 100644 --- a/src/runloop_api_client/_version.py +++ b/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.63.0" # x-release-please-version +__version__ = "0.64.0" # x-release-please-version