diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ea2682c30..52afe059d 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.41.0" + ".": "0.42.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index d90c138a9..9af3f652d 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 87 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-028690466821f7d03fc038928ce12d65025db071b8a74b9c1fb39309e40a99ec.yml -openapi_spec_hash: a6433c9e1bcf8cb3b4e23413ad6f7f11 +configured_endpoints: 91 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/runloop-ai%2Frunloop-86c4a065b1820b26c7afd40bbc374e87dd5e9c2ffa0abad26e7fd4ebec1cf72b.yml +openapi_spec_hash: 6c6a44548177464033f3c174c89ba06a config_hash: 421e8d0e71c7ef71fdfebede08ea7271 diff --git a/CHANGELOG.md b/CHANGELOG.md index 161c8513c..f5b4780ff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.42.0 (2025-06-11) + +Full Changelog: [v0.41.0...v0.42.0](https://github.com/runloopai/api-client-python/compare/v0.41.0...v0.42.0) + +### Features + +* **api:** api update ([6cdcab7](https://github.com/runloopai/api-client-python/commit/6cdcab70311f7344b28867e1bc0310370618dac8)) + ## 0.41.0 (2025-06-10) Full Changelog: [v0.40.0...v0.41.0](https://github.com/runloopai/api-client-python/compare/v0.40.0...v0.41.0) diff --git a/api.md b/api.md index ce2831ca0..da4195d42 100644 --- a/api.md +++ b/api.md @@ -340,3 +340,23 @@ Methods: - client.repositories.delete(id) -> object - client.repositories.list_inspections(id) -> RepositoryInspectionListView - client.repositories.refresh(id, \*\*params) -> object + +# Secrets + +Types: + +```python +from runloop_api_client.types import ( + SecretCreateParameters, + SecretListView, + SecretUpdateParameters, + SecretView, +) +``` + +Methods: + +- client.secrets.create(\*\*params) -> SecretView +- client.secrets.update(name, \*\*params) -> SecretView +- client.secrets.list() -> SecretListView +- client.secrets.delete(name) -> SecretView diff --git a/pyproject.toml b/pyproject.toml index c2161ff26..c61d56fec 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "runloop_api_client" -version = "0.41.0" +version = "0.42.0" description = "The official Python library for the runloop API" dynamic = ["readme"] license = "MIT" diff --git a/src/runloop_api_client/_client.py b/src/runloop_api_client/_client.py index babaea83b..ff8c86578 100644 --- a/src/runloop_api_client/_client.py +++ b/src/runloop_api_client/_client.py @@ -21,7 +21,7 @@ ) from ._utils import is_given, get_async_library from ._version import __version__ -from .resources import blueprints, repositories +from .resources import secrets, blueprints, repositories from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import RunloopError, APIStatusError from ._base_client import ( @@ -42,6 +42,7 @@ class Runloop(SyncAPIClient): devboxes: devboxes.DevboxesResource scenarios: scenarios.ScenariosResource repositories: repositories.RepositoriesResource + secrets: secrets.SecretsResource with_raw_response: RunloopWithRawResponse with_streaming_response: RunloopWithStreamedResponse @@ -106,6 +107,7 @@ def __init__( self.devboxes = devboxes.DevboxesResource(self) self.scenarios = scenarios.ScenariosResource(self) self.repositories = repositories.RepositoriesResource(self) + self.secrets = secrets.SecretsResource(self) self.with_raw_response = RunloopWithRawResponse(self) self.with_streaming_response = RunloopWithStreamedResponse(self) @@ -220,6 +222,7 @@ class AsyncRunloop(AsyncAPIClient): devboxes: devboxes.AsyncDevboxesResource scenarios: scenarios.AsyncScenariosResource repositories: repositories.AsyncRepositoriesResource + secrets: secrets.AsyncSecretsResource with_raw_response: AsyncRunloopWithRawResponse with_streaming_response: AsyncRunloopWithStreamedResponse @@ -284,6 +287,7 @@ def __init__( self.devboxes = devboxes.AsyncDevboxesResource(self) self.scenarios = scenarios.AsyncScenariosResource(self) self.repositories = repositories.AsyncRepositoriesResource(self) + self.secrets = secrets.AsyncSecretsResource(self) self.with_raw_response = AsyncRunloopWithRawResponse(self) self.with_streaming_response = AsyncRunloopWithStreamedResponse(self) @@ -399,6 +403,7 @@ def __init__(self, client: Runloop) -> None: self.devboxes = devboxes.DevboxesResourceWithRawResponse(client.devboxes) self.scenarios = scenarios.ScenariosResourceWithRawResponse(client.scenarios) self.repositories = repositories.RepositoriesResourceWithRawResponse(client.repositories) + self.secrets = secrets.SecretsResourceWithRawResponse(client.secrets) class AsyncRunloopWithRawResponse: @@ -408,6 +413,7 @@ def __init__(self, client: AsyncRunloop) -> None: self.devboxes = devboxes.AsyncDevboxesResourceWithRawResponse(client.devboxes) self.scenarios = scenarios.AsyncScenariosResourceWithRawResponse(client.scenarios) self.repositories = repositories.AsyncRepositoriesResourceWithRawResponse(client.repositories) + self.secrets = secrets.AsyncSecretsResourceWithRawResponse(client.secrets) class RunloopWithStreamedResponse: @@ -417,6 +423,7 @@ def __init__(self, client: Runloop) -> None: self.devboxes = devboxes.DevboxesResourceWithStreamingResponse(client.devboxes) self.scenarios = scenarios.ScenariosResourceWithStreamingResponse(client.scenarios) self.repositories = repositories.RepositoriesResourceWithStreamingResponse(client.repositories) + self.secrets = secrets.SecretsResourceWithStreamingResponse(client.secrets) class AsyncRunloopWithStreamedResponse: @@ -426,6 +433,7 @@ def __init__(self, client: AsyncRunloop) -> None: self.devboxes = devboxes.AsyncDevboxesResourceWithStreamingResponse(client.devboxes) self.scenarios = scenarios.AsyncScenariosResourceWithStreamingResponse(client.scenarios) self.repositories = repositories.AsyncRepositoriesResourceWithStreamingResponse(client.repositories) + self.secrets = secrets.AsyncSecretsResourceWithStreamingResponse(client.secrets) Client = Runloop diff --git a/src/runloop_api_client/_version.py b/src/runloop_api_client/_version.py index 262799d1e..dee24268d 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.41.0" # x-release-please-version +__version__ = "0.42.0" # x-release-please-version diff --git a/src/runloop_api_client/resources/__init__.py b/src/runloop_api_client/resources/__init__.py index 2c103b15e..c493ac8c7 100644 --- a/src/runloop_api_client/resources/__init__.py +++ b/src/runloop_api_client/resources/__init__.py @@ -1,5 +1,13 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. +from .secrets import ( + SecretsResource, + AsyncSecretsResource, + SecretsResourceWithRawResponse, + AsyncSecretsResourceWithRawResponse, + SecretsResourceWithStreamingResponse, + AsyncSecretsResourceWithStreamingResponse, +) from .devboxes import ( DevboxesResource, AsyncDevboxesResource, @@ -72,4 +80,10 @@ "AsyncRepositoriesResourceWithRawResponse", "RepositoriesResourceWithStreamingResponse", "AsyncRepositoriesResourceWithStreamingResponse", + "SecretsResource", + "AsyncSecretsResource", + "SecretsResourceWithRawResponse", + "AsyncSecretsResourceWithRawResponse", + "SecretsResourceWithStreamingResponse", + "AsyncSecretsResourceWithStreamingResponse", ] diff --git a/src/runloop_api_client/resources/secrets.py b/src/runloop_api_client/resources/secrets.py new file mode 100644 index 000000000..d6eb94c7a --- /dev/null +++ b/src/runloop_api_client/resources/secrets.py @@ -0,0 +1,468 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..types import secret_create_params, secret_update_params +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import maybe_transform, async_maybe_transform +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from .._base_client import make_request_options +from ..types.secret_view import SecretView +from ..types.secret_list_view import SecretListView + +__all__ = ["SecretsResource", "AsyncSecretsResource"] + + +class SecretsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> SecretsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/runloopai/api-client-python#accessing-raw-response-data-eg-headers + """ + return SecretsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SecretsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/runloopai/api-client-python#with_streaming_response + """ + return SecretsResourceWithStreamingResponse(self) + + def create( + self, + *, + name: str, + value: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Create a new Secret with a globally unique name and value. + + The Secret will be + encrypted at rest and made available as an environment variable in Devboxes. + + Args: + name: The globally unique name for the Secret. Must be a valid environment variable + name (alphanumeric and underscores only). Example: 'DATABASE_PASSWORD' + + value: The value to store for this Secret. This will be encrypted at rest and made + available as an environment variable in Devboxes. Example: 'my-secure-password' + + 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 + """ + return self._post( + "/v1/secrets", + body=maybe_transform( + { + "name": name, + "value": value, + }, + secret_create_params.SecretCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + def update( + self, + name: str, + *, + value: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Update the value of an existing Secret by name. + + The new value will be encrypted + at rest. + + Args: + value: The new value for the Secret. This will replace the existing value and be + encrypted at rest. Example: 'my-updated-secure-password' + + 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 name: + raise ValueError(f"Expected a non-empty value for `name` but received {name!r}") + return self._post( + f"/v1/secrets/{name}", + body=maybe_transform({"value": value}, secret_update_params.SecretUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + def list( + self, + *, + # 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, + ) -> SecretListView: + """List all Secrets for the authenticated account. + + Secret values are not included + for security reasons. + """ + return self._get( + "/v1/secrets", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=SecretListView, + ) + + def delete( + self, + name: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Delete an existing Secret by name. + + This action is irreversible and will remove + the Secret from all Devboxes. + + 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 + + idempotency_key: Specify a custom idempotency key for this request + """ + if not name: + raise ValueError(f"Expected a non-empty value for `name` but received {name!r}") + return self._post( + f"/v1/secrets/{name}/delete", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + +class AsyncSecretsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncSecretsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/runloopai/api-client-python#accessing-raw-response-data-eg-headers + """ + return AsyncSecretsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSecretsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/runloopai/api-client-python#with_streaming_response + """ + return AsyncSecretsResourceWithStreamingResponse(self) + + async def create( + self, + *, + name: str, + value: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Create a new Secret with a globally unique name and value. + + The Secret will be + encrypted at rest and made available as an environment variable in Devboxes. + + Args: + name: The globally unique name for the Secret. Must be a valid environment variable + name (alphanumeric and underscores only). Example: 'DATABASE_PASSWORD' + + value: The value to store for this Secret. This will be encrypted at rest and made + available as an environment variable in Devboxes. Example: 'my-secure-password' + + 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 + """ + return await self._post( + "/v1/secrets", + body=await async_maybe_transform( + { + "name": name, + "value": value, + }, + secret_create_params.SecretCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + async def update( + self, + name: str, + *, + value: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Update the value of an existing Secret by name. + + The new value will be encrypted + at rest. + + Args: + value: The new value for the Secret. This will replace the existing value and be + encrypted at rest. Example: 'my-updated-secure-password' + + 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 name: + raise ValueError(f"Expected a non-empty value for `name` but received {name!r}") + return await self._post( + f"/v1/secrets/{name}", + body=await async_maybe_transform({"value": value}, secret_update_params.SecretUpdateParams), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + async def list( + self, + *, + # 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, + ) -> SecretListView: + """List all Secrets for the authenticated account. + + Secret values are not included + for security reasons. + """ + return await self._get( + "/v1/secrets", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=SecretListView, + ) + + async def delete( + self, + name: 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, + idempotency_key: str | None = None, + ) -> SecretView: + """Delete an existing Secret by name. + + This action is irreversible and will remove + the Secret from all Devboxes. + + 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 + + idempotency_key: Specify a custom idempotency key for this request + """ + if not name: + raise ValueError(f"Expected a non-empty value for `name` but received {name!r}") + return await self._post( + f"/v1/secrets/{name}/delete", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=SecretView, + ) + + +class SecretsResourceWithRawResponse: + def __init__(self, secrets: SecretsResource) -> None: + self._secrets = secrets + + self.create = to_raw_response_wrapper( + secrets.create, + ) + self.update = to_raw_response_wrapper( + secrets.update, + ) + self.list = to_raw_response_wrapper( + secrets.list, + ) + self.delete = to_raw_response_wrapper( + secrets.delete, + ) + + +class AsyncSecretsResourceWithRawResponse: + def __init__(self, secrets: AsyncSecretsResource) -> None: + self._secrets = secrets + + self.create = async_to_raw_response_wrapper( + secrets.create, + ) + self.update = async_to_raw_response_wrapper( + secrets.update, + ) + self.list = async_to_raw_response_wrapper( + secrets.list, + ) + self.delete = async_to_raw_response_wrapper( + secrets.delete, + ) + + +class SecretsResourceWithStreamingResponse: + def __init__(self, secrets: SecretsResource) -> None: + self._secrets = secrets + + self.create = to_streamed_response_wrapper( + secrets.create, + ) + self.update = to_streamed_response_wrapper( + secrets.update, + ) + self.list = to_streamed_response_wrapper( + secrets.list, + ) + self.delete = to_streamed_response_wrapper( + secrets.delete, + ) + + +class AsyncSecretsResourceWithStreamingResponse: + def __init__(self, secrets: AsyncSecretsResource) -> None: + self._secrets = secrets + + self.create = async_to_streamed_response_wrapper( + secrets.create, + ) + self.update = async_to_streamed_response_wrapper( + secrets.update, + ) + self.list = async_to_streamed_response_wrapper( + secrets.list, + ) + self.delete = async_to_streamed_response_wrapper( + secrets.delete, + ) diff --git a/src/runloop_api_client/types/__init__.py b/src/runloop_api_client/types/__init__.py index 3428ea1c9..12c611295 100644 --- a/src/runloop_api_client/types/__init__.py +++ b/src/runloop_api_client/types/__init__.py @@ -8,6 +8,7 @@ CodeMountParameters as CodeMountParameters, ) from .devbox_view import DevboxView as DevboxView +from .secret_view import SecretView as SecretView from .input_context import InputContext as InputContext from .scenario_view import ScenarioView as ScenarioView from .benchmark_view import BenchmarkView as BenchmarkView @@ -15,6 +16,7 @@ from .devbox_list_view import DevboxListView as DevboxListView from .scoring_contract import ScoringContract as ScoringContract from .scoring_function import ScoringFunction as ScoringFunction +from .secret_list_view import SecretListView as SecretListView from .scenario_run_view import ScenarioRunView as ScenarioRunView from .benchmark_run_view import BenchmarkRunView as BenchmarkRunView from .devbox_list_params import DevboxListParams as DevboxListParams @@ -27,6 +29,8 @@ from .devbox_update_params import DevboxUpdateParams as DevboxUpdateParams from .scenario_environment import ScenarioEnvironment as ScenarioEnvironment from .scenario_list_params import ScenarioListParams as ScenarioListParams +from .secret_create_params import SecretCreateParams as SecretCreateParams +from .secret_update_params import SecretUpdateParams as SecretUpdateParams from .benchmark_list_params import BenchmarkListParams as BenchmarkListParams from .blueprint_list_params import BlueprintListParams as BlueprintListParams from .blueprint_preview_view import BlueprintPreviewView as BlueprintPreviewView diff --git a/src/runloop_api_client/types/secret_create_params.py b/src/runloop_api_client/types/secret_create_params.py new file mode 100644 index 000000000..5d5234b56 --- /dev/null +++ b/src/runloop_api_client/types/secret_create_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 Required, TypedDict + +__all__ = ["SecretCreateParams"] + + +class SecretCreateParams(TypedDict, total=False): + name: Required[str] + """The globally unique name for the Secret. + + Must be a valid environment variable name (alphanumeric and underscores only). + Example: 'DATABASE_PASSWORD' + """ + + value: Required[str] + """The value to store for this Secret. + + This will be encrypted at rest and made available as an environment variable in + Devboxes. Example: 'my-secure-password' + """ diff --git a/src/runloop_api_client/types/secret_list_view.py b/src/runloop_api_client/types/secret_list_view.py new file mode 100644 index 000000000..d7feec9c5 --- /dev/null +++ b/src/runloop_api_client/types/secret_list_view.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from .._models import BaseModel +from .secret_view import SecretView + +__all__ = ["SecretListView"] + + +class SecretListView(BaseModel): + has_more: bool + """True if there are more results available beyond this page.""" + + remaining_count: int + """Number of Secrets remaining after this page.""" + + secrets: List[SecretView] + """List of Secret objects. Values are omitted for security.""" + + total_count: int + """Total number of Secrets across all pages.""" diff --git a/src/runloop_api_client/types/secret_update_params.py b/src/runloop_api_client/types/secret_update_params.py new file mode 100644 index 000000000..5b5af9a0f --- /dev/null +++ b/src/runloop_api_client/types/secret_update_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["SecretUpdateParams"] + + +class SecretUpdateParams(TypedDict, total=False): + value: Required[str] + """The new value for the Secret. + + This will replace the existing value and be encrypted at rest. Example: + 'my-updated-secure-password' + """ diff --git a/src/runloop_api_client/types/secret_view.py b/src/runloop_api_client/types/secret_view.py new file mode 100644 index 000000000..1303f7bfd --- /dev/null +++ b/src/runloop_api_client/types/secret_view.py @@ -0,0 +1,22 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .._models import BaseModel + +__all__ = ["SecretView"] + + +class SecretView(BaseModel): + id: str + """The unique identifier of the Secret.""" + + create_time_ms: int + """Creation time of the Secret (Unix timestamp in milliseconds).""" + + name: str + """The globally unique name of the Secret. + + Used as the environment variable name in Devboxes. + """ + + update_time_ms: int + """Last update time of the Secret (Unix timestamp in milliseconds).""" diff --git a/tests/api_resources/test_secrets.py b/tests/api_resources/test_secrets.py new file mode 100644 index 000000000..730447d77 --- /dev/null +++ b/tests/api_resources/test_secrets.py @@ -0,0 +1,300 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from runloop_api_client import Runloop, AsyncRunloop +from runloop_api_client.types import SecretView, SecretListView + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestSecrets: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: Runloop) -> None: + secret = client.secrets.create( + name="name", + value="value", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_raw_response_create(self, client: Runloop) -> None: + response = client.secrets.with_raw_response.create( + name="name", + value="value", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_streaming_response_create(self, client: Runloop) -> None: + with client.secrets.with_streaming_response.create( + name="name", + value="value", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_update(self, client: Runloop) -> None: + secret = client.secrets.update( + name="name", + value="value", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_raw_response_update(self, client: Runloop) -> None: + response = client.secrets.with_raw_response.update( + name="name", + value="value", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_streaming_response_update(self, client: Runloop) -> None: + with client.secrets.with_streaming_response.update( + name="name", + value="value", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_update(self, client: Runloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `name` but received ''"): + client.secrets.with_raw_response.update( + name="", + value="value", + ) + + @parametrize + def test_method_list(self, client: Runloop) -> None: + secret = client.secrets.list() + assert_matches_type(SecretListView, secret, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: Runloop) -> None: + response = client.secrets.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = response.parse() + assert_matches_type(SecretListView, secret, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: Runloop) -> None: + with client.secrets.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = response.parse() + assert_matches_type(SecretListView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_delete(self, client: Runloop) -> None: + secret = client.secrets.delete( + "name", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_raw_response_delete(self, client: Runloop) -> None: + response = client.secrets.with_raw_response.delete( + "name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + def test_streaming_response_delete(self, client: Runloop) -> None: + with client.secrets.with_streaming_response.delete( + "name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_delete(self, client: Runloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `name` but received ''"): + client.secrets.with_raw_response.delete( + "", + ) + + +class TestAsyncSecrets: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_create(self, async_client: AsyncRunloop) -> None: + secret = await async_client.secrets.create( + name="name", + value="value", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_raw_response_create(self, async_client: AsyncRunloop) -> None: + response = await async_client.secrets.with_raw_response.create( + name="name", + value="value", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncRunloop) -> None: + async with async_client.secrets.with_streaming_response.create( + name="name", + value="value", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_update(self, async_client: AsyncRunloop) -> None: + secret = await async_client.secrets.update( + name="name", + value="value", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_raw_response_update(self, async_client: AsyncRunloop) -> None: + response = await async_client.secrets.with_raw_response.update( + name="name", + value="value", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_streaming_response_update(self, async_client: AsyncRunloop) -> None: + async with async_client.secrets.with_streaming_response.update( + name="name", + value="value", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_update(self, async_client: AsyncRunloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `name` but received ''"): + await async_client.secrets.with_raw_response.update( + name="", + value="value", + ) + + @parametrize + async def test_method_list(self, async_client: AsyncRunloop) -> None: + secret = await async_client.secrets.list() + assert_matches_type(SecretListView, secret, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncRunloop) -> None: + response = await async_client.secrets.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = await response.parse() + assert_matches_type(SecretListView, secret, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncRunloop) -> None: + async with async_client.secrets.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = await response.parse() + assert_matches_type(SecretListView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_delete(self, async_client: AsyncRunloop) -> None: + secret = await async_client.secrets.delete( + "name", + ) + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_raw_response_delete(self, async_client: AsyncRunloop) -> None: + response = await async_client.secrets.with_raw_response.delete( + "name", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncRunloop) -> None: + async with async_client.secrets.with_streaming_response.delete( + "name", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + secret = await response.parse() + assert_matches_type(SecretView, secret, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_delete(self, async_client: AsyncRunloop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `name` but received ''"): + await async_client.secrets.with_raw_response.delete( + "", + )