diff --git a/.stats.yml b/.stats.yml index 33d57b57..d82d85ce 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 14 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/arcade-ai%2Farcade-engine-c089b91b0e1c2bc2e6a5bd42454c82a162957011f1d8469c680a82ff05ee9ec9.yml +configured_endpoints: 17 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/arcade-ai%2Farcade-engine-a71adfaff442ffd07aa4f46ea5d967ca0faf6ea9ddfee5cc2f0bd9615b891684.yml diff --git a/api.md b/api.md index 1fb480a3..856b6744 100644 --- a/api.md +++ b/api.md @@ -109,4 +109,7 @@ from arcadepy.types import ( Methods: - client.worker.create(\*\*params) -> WorkerResponse +- client.worker.update(id, \*\*params) -> WorkerResponse - client.worker.list() -> WorkerListResponse +- client.worker.delete(id) -> None +- client.worker.health(id) -> WorkerHealthResponse diff --git a/src/arcadepy/resources/worker.py b/src/arcadepy/resources/worker.py index 827013d0..90a3505e 100644 --- a/src/arcadepy/resources/worker.py +++ b/src/arcadepy/resources/worker.py @@ -4,8 +4,8 @@ import httpx -from ..types import worker_create_params -from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ..types import worker_create_params, worker_update_params +from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven from .._utils import ( maybe_transform, async_maybe_transform, @@ -21,6 +21,7 @@ from .._base_client import make_request_options from ..types.worker_response import WorkerResponse from ..types.worker_list_response import WorkerListResponse +from ..types.worker_health_response import WorkerHealthResponse __all__ = ["WorkerResource", "AsyncWorkerResource"] @@ -86,6 +87,48 @@ def create( cast_to=WorkerResponse, ) + def update( + self, + id: str, + *, + enabled: bool | NotGiven = NOT_GIVEN, + http: worker_update_params.HTTP | NotGiven = NOT_GIVEN, + # 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, + ) -> WorkerResponse: + """ + Update a worker + + 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._patch( + f"/v1/admin/workers/{id}", + body=maybe_transform( + { + "enabled": enabled, + "http": http, + }, + worker_update_params.WorkerUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=WorkerResponse, + ) + def list( self, *, @@ -105,6 +148,73 @@ def list( cast_to=WorkerListResponse, ) + def delete( + 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, + ) -> None: + """ + Delete a worker + + 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}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._delete( + f"/v1/admin/workers/{id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + def health( + 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, + ) -> WorkerHealthResponse: + """ + Get the health of a worker + + 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/admin/workers/{id}/health", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=WorkerHealthResponse, + ) + class AsyncWorkerResource(AsyncAPIResource): @cached_property @@ -167,6 +277,48 @@ async def create( cast_to=WorkerResponse, ) + async def update( + self, + id: str, + *, + enabled: bool | NotGiven = NOT_GIVEN, + http: worker_update_params.HTTP | NotGiven = NOT_GIVEN, + # 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, + ) -> WorkerResponse: + """ + Update a worker + + 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._patch( + f"/v1/admin/workers/{id}", + body=await async_maybe_transform( + { + "enabled": enabled, + "http": http, + }, + worker_update_params.WorkerUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=WorkerResponse, + ) + async def list( self, *, @@ -186,6 +338,73 @@ async def list( cast_to=WorkerListResponse, ) + async def delete( + 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, + ) -> None: + """ + Delete a worker + + 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}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._delete( + f"/v1/admin/workers/{id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + async def health( + 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, + ) -> WorkerHealthResponse: + """ + Get the health of a worker + + 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/admin/workers/{id}/health", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=WorkerHealthResponse, + ) + class WorkerResourceWithRawResponse: def __init__(self, worker: WorkerResource) -> None: @@ -194,9 +413,18 @@ def __init__(self, worker: WorkerResource) -> None: self.create = to_raw_response_wrapper( worker.create, ) + self.update = to_raw_response_wrapper( + worker.update, + ) self.list = to_raw_response_wrapper( worker.list, ) + self.delete = to_raw_response_wrapper( + worker.delete, + ) + self.health = to_raw_response_wrapper( + worker.health, + ) class AsyncWorkerResourceWithRawResponse: @@ -206,9 +434,18 @@ def __init__(self, worker: AsyncWorkerResource) -> None: self.create = async_to_raw_response_wrapper( worker.create, ) + self.update = async_to_raw_response_wrapper( + worker.update, + ) self.list = async_to_raw_response_wrapper( worker.list, ) + self.delete = async_to_raw_response_wrapper( + worker.delete, + ) + self.health = async_to_raw_response_wrapper( + worker.health, + ) class WorkerResourceWithStreamingResponse: @@ -218,9 +455,18 @@ def __init__(self, worker: WorkerResource) -> None: self.create = to_streamed_response_wrapper( worker.create, ) + self.update = to_streamed_response_wrapper( + worker.update, + ) self.list = to_streamed_response_wrapper( worker.list, ) + self.delete = to_streamed_response_wrapper( + worker.delete, + ) + self.health = to_streamed_response_wrapper( + worker.health, + ) class AsyncWorkerResourceWithStreamingResponse: @@ -230,6 +476,15 @@ def __init__(self, worker: AsyncWorkerResource) -> None: self.create = async_to_streamed_response_wrapper( worker.create, ) + self.update = async_to_streamed_response_wrapper( + worker.update, + ) self.list = async_to_streamed_response_wrapper( worker.list, ) + self.delete = async_to_streamed_response_wrapper( + worker.delete, + ) + self.health = async_to_streamed_response_wrapper( + worker.health, + ) diff --git a/src/arcadepy/types/__init__.py b/src/arcadepy/types/__init__.py index e01175e0..ba48f78c 100644 --- a/src/arcadepy/types/__init__.py +++ b/src/arcadepy/types/__init__.py @@ -22,7 +22,9 @@ from .tool_execute_params import ToolExecuteParams as ToolExecuteParams from .worker_create_params import WorkerCreateParams as WorkerCreateParams from .worker_list_response import WorkerListResponse as WorkerListResponse +from .worker_update_params import WorkerUpdateParams as WorkerUpdateParams from .auth_authorize_params import AuthAuthorizeParams as AuthAuthorizeParams from .execute_tool_response import ExecuteToolResponse as ExecuteToolResponse from .tool_authorize_params import ToolAuthorizeParams as ToolAuthorizeParams from .tool_execution_attempt import ToolExecutionAttempt as ToolExecutionAttempt +from .worker_health_response import WorkerHealthResponse as WorkerHealthResponse diff --git a/src/arcadepy/types/worker_health_response.py b/src/arcadepy/types/worker_health_response.py new file mode 100644 index 00000000..de205212 --- /dev/null +++ b/src/arcadepy/types/worker_health_response.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from .._models import BaseModel + +__all__ = ["WorkerHealthResponse"] + + +class WorkerHealthResponse(BaseModel): + id: Optional[str] = None + + enabled: Optional[bool] = None + + healthy: Optional[bool] = None + + message: Optional[str] = None diff --git a/src/arcadepy/types/worker_update_params.py b/src/arcadepy/types/worker_update_params.py new file mode 100644 index 00000000..0215ac17 --- /dev/null +++ b/src/arcadepy/types/worker_update_params.py @@ -0,0 +1,23 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import TypedDict + +__all__ = ["WorkerUpdateParams", "HTTP"] + + +class WorkerUpdateParams(TypedDict, total=False): + enabled: bool + + http: HTTP + + +class HTTP(TypedDict, total=False): + retry: int + + secret: str + + timeout: int + + uri: str diff --git a/tests/api_resources/test_worker.py b/tests/api_resources/test_worker.py index 34682074..b94150bd 100644 --- a/tests/api_resources/test_worker.py +++ b/tests/api_resources/test_worker.py @@ -9,7 +9,11 @@ from arcadepy import Arcade, AsyncArcade from tests.utils import assert_matches_type -from arcadepy.types import WorkerResponse, WorkerListResponse +from arcadepy.types import ( + WorkerResponse, + WorkerListResponse, + WorkerHealthResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -65,6 +69,58 @@ def test_streaming_response_create(self, client: Arcade) -> None: assert cast(Any, response.is_closed) is True + @parametrize + def test_method_update(self, client: Arcade) -> None: + worker = client.worker.update( + id="id", + ) + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + def test_method_update_with_all_params(self, client: Arcade) -> None: + worker = client.worker.update( + id="id", + enabled=True, + http={ + "retry": 0, + "secret": "secret", + "timeout": 1, + "uri": "uri", + }, + ) + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + def test_raw_response_update(self, client: Arcade) -> None: + response = client.worker.with_raw_response.update( + id="id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = response.parse() + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + def test_streaming_response_update(self, client: Arcade) -> None: + with client.worker.with_streaming_response.update( + id="id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = response.parse() + assert_matches_type(WorkerResponse, worker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_update(self, client: Arcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.worker.with_raw_response.update( + id="", + ) + @parametrize def test_method_list(self, client: Arcade) -> None: worker = client.worker.list() @@ -90,6 +146,82 @@ def test_streaming_response_list(self, client: Arcade) -> None: assert cast(Any, response.is_closed) is True + @parametrize + def test_method_delete(self, client: Arcade) -> None: + worker = client.worker.delete( + "id", + ) + assert worker is None + + @parametrize + def test_raw_response_delete(self, client: Arcade) -> None: + response = client.worker.with_raw_response.delete( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = response.parse() + assert worker is None + + @parametrize + def test_streaming_response_delete(self, client: Arcade) -> None: + with client.worker.with_streaming_response.delete( + "id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = response.parse() + assert worker is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_delete(self, client: Arcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.worker.with_raw_response.delete( + "", + ) + + @parametrize + def test_method_health(self, client: Arcade) -> None: + worker = client.worker.health( + "id", + ) + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + @parametrize + def test_raw_response_health(self, client: Arcade) -> None: + response = client.worker.with_raw_response.health( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = response.parse() + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + @parametrize + def test_streaming_response_health(self, client: Arcade) -> None: + with client.worker.with_streaming_response.health( + "id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = response.parse() + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_health(self, client: Arcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.worker.with_raw_response.health( + "", + ) + class TestAsyncWorker: parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) @@ -142,6 +274,58 @@ async def test_streaming_response_create(self, async_client: AsyncArcade) -> Non assert cast(Any, response.is_closed) is True + @parametrize + async def test_method_update(self, async_client: AsyncArcade) -> None: + worker = await async_client.worker.update( + id="id", + ) + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncArcade) -> None: + worker = await async_client.worker.update( + id="id", + enabled=True, + http={ + "retry": 0, + "secret": "secret", + "timeout": 1, + "uri": "uri", + }, + ) + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + async def test_raw_response_update(self, async_client: AsyncArcade) -> None: + response = await async_client.worker.with_raw_response.update( + id="id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = await response.parse() + assert_matches_type(WorkerResponse, worker, path=["response"]) + + @parametrize + async def test_streaming_response_update(self, async_client: AsyncArcade) -> None: + async with async_client.worker.with_streaming_response.update( + id="id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = await response.parse() + assert_matches_type(WorkerResponse, worker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_update(self, async_client: AsyncArcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.worker.with_raw_response.update( + id="", + ) + @parametrize async def test_method_list(self, async_client: AsyncArcade) -> None: worker = await async_client.worker.list() @@ -166,3 +350,79 @@ async def test_streaming_response_list(self, async_client: AsyncArcade) -> None: assert_matches_type(WorkerListResponse, worker, path=["response"]) assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_delete(self, async_client: AsyncArcade) -> None: + worker = await async_client.worker.delete( + "id", + ) + assert worker is None + + @parametrize + async def test_raw_response_delete(self, async_client: AsyncArcade) -> None: + response = await async_client.worker.with_raw_response.delete( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = await response.parse() + assert worker is None + + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncArcade) -> None: + async with async_client.worker.with_streaming_response.delete( + "id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = await response.parse() + assert worker is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_delete(self, async_client: AsyncArcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.worker.with_raw_response.delete( + "", + ) + + @parametrize + async def test_method_health(self, async_client: AsyncArcade) -> None: + worker = await async_client.worker.health( + "id", + ) + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + @parametrize + async def test_raw_response_health(self, async_client: AsyncArcade) -> None: + response = await async_client.worker.with_raw_response.health( + "id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + worker = await response.parse() + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + @parametrize + async def test_streaming_response_health(self, async_client: AsyncArcade) -> None: + async with async_client.worker.with_streaming_response.health( + "id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + worker = await response.parse() + assert_matches_type(WorkerHealthResponse, worker, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_health(self, async_client: AsyncArcade) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.worker.with_raw_response.health( + "", + )