diff --git a/.release-please-manifest.json b/.release-please-manifest.json index f57aac48..a1e0736b 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.3.1-alpha.2" + ".": "0.4.0-alpha.1" } diff --git a/.stats.yml b/.stats.yml index 49885bb5..60e64c3c 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 104 +configured_endpoints: 111 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/llamastack%2Fllama-stack-client-35c6569e5e9fcc85084c9728eb7fc7c5908297fcc77043d621d25de3c850a990.yml openapi_spec_hash: 0f95bbeee16f3205d36ec34cfa62c711 -config_hash: a3829dbdaa491194d01f399784d532cd +config_hash: ef275cc002a89629459fd73d0cf9cba9 diff --git a/CHANGELOG.md b/CHANGELOG.md index c2ebd74f..ab7d3936 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,32 @@ # Changelog +## 0.4.0-alpha.1 (2025-10-30) + +Full Changelog: [v0.3.1-alpha.2...v0.4.0-alpha.1](https://github.com/llamastack/llama-stack-client-python/compare/v0.3.1-alpha.2...v0.4.0-alpha.1) + +### ⚠ BREAKING CHANGES + +* **api:** /v1/inspect only lists v1 apis by default +* **api:** /v1/inspect only lists v1 apis by default + +### Features + +* **api:** Adding prompts API to stainless config ([114198b](https://github.com/llamastack/llama-stack-client-python/commit/114198bef4244ec27f7e163beb2e554da0dbd213)) +* **api:** manual updates??! ([d8ab6cb](https://github.com/llamastack/llama-stack-client-python/commit/d8ab6cb77267af53f3f2e9ff3ebaab9364a754c7)) + + +### Bug Fixes + +* clean pre-commit ([799b908](https://github.com/llamastack/llama-stack-client-python/commit/799b9084266c390604829dd1eef483bf3b941134)) +* **client:** close streams without requiring full consumption ([d861708](https://github.com/llamastack/llama-stack-client-python/commit/d8617084062acbb81c26b6c22ea613e397aa969b)) +* **headers:** add a newline ([55a8efc](https://github.com/llamastack/llama-stack-client-python/commit/55a8efc0a60f44c8c93e18b2b60215f051405be4)) + + +### Chores + +* **api:** /v1/inspect only lists v1 apis by default ([209de45](https://github.com/llamastack/llama-stack-client-python/commit/209de45599de19183a1cd14bc3567e34d2374184)) +* **api:** /v1/inspect only lists v1 apis by default ([b36e2ab](https://github.com/llamastack/llama-stack-client-python/commit/b36e2ab8661e4913838c2cb4501156b290876da0)) + ## 0.3.1-alpha.2 (2025-10-27) Full Changelog: [v0.3.1-alpha.1...v0.3.1-alpha.2](https://github.com/llamastack/llama-stack-client-python/compare/v0.3.1-alpha.1...v0.3.1-alpha.2) diff --git a/api.md b/api.md index 5f7a90a2..57ecd092 100644 --- a/api.md +++ b/api.md @@ -102,6 +102,29 @@ Methods: - client.responses.input_items.list(response_id, \*\*params) -> InputItemListResponse +# Prompts + +Types: + +```python +from llama_stack_client.types import ListPromptsResponse, Prompt, PromptListResponse +``` + +Methods: + +- client.prompts.create(\*\*params) -> Prompt +- client.prompts.retrieve(prompt_id, \*\*params) -> Prompt +- client.prompts.update(prompt_id, \*\*params) -> Prompt +- client.prompts.list() -> PromptListResponse +- client.prompts.delete(prompt_id) -> None +- client.prompts.set_default_version(prompt_id, \*\*params) -> Prompt + +## Versions + +Methods: + +- client.prompts.versions.list(prompt_id) -> PromptListResponse + # Conversations Types: diff --git a/pyproject.toml b/pyproject.toml index 3e7e62aa..1b1f5563 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "llama_stack_client" -version = "0.3.1-alpha.2" +version = "0.4.0-alpha.1" description = "The official Python library for the llama-stack-client API" dynamic = ["readme"] license = "MIT" diff --git a/src/llama_stack_client/_client.py b/src/llama_stack_client/_client.py index 34de181a..b1880a7e 100644 --- a/src/llama_stack_client/_client.py +++ b/src/llama_stack_client/_client.py @@ -48,6 +48,7 @@ routes, safety, inspect, + prompts, scoring, shields, providers, @@ -80,6 +81,7 @@ from .resources.completions import CompletionsResource, AsyncCompletionsResource from .resources.moderations import ModerationsResource, AsyncModerationsResource from .resources.models.models import ModelsResource, AsyncModelsResource + from .resources.prompts.prompts import PromptsResource, AsyncPromptsResource from .resources.scoring_functions import ScoringFunctionsResource, AsyncScoringFunctionsResource from .resources.responses.responses import ResponsesResource, AsyncResponsesResource from .resources.synthetic_data_generation import ( @@ -183,6 +185,12 @@ def responses(self) -> ResponsesResource: return ResponsesResource(self) + @cached_property + def prompts(self) -> PromptsResource: + from .resources.prompts import PromptsResource + + return PromptsResource(self) + @cached_property def conversations(self) -> ConversationsResource: from .resources.conversations import ConversationsResource @@ -493,6 +501,12 @@ def responses(self) -> AsyncResponsesResource: return AsyncResponsesResource(self) + @cached_property + def prompts(self) -> AsyncPromptsResource: + from .resources.prompts import AsyncPromptsResource + + return AsyncPromptsResource(self) + @cached_property def conversations(self) -> AsyncConversationsResource: from .resources.conversations import AsyncConversationsResource @@ -752,6 +766,12 @@ def responses(self) -> responses.ResponsesResourceWithRawResponse: return ResponsesResourceWithRawResponse(self._client.responses) + @cached_property + def prompts(self) -> prompts.PromptsResourceWithRawResponse: + from .resources.prompts import PromptsResourceWithRawResponse + + return PromptsResourceWithRawResponse(self._client.prompts) + @cached_property def conversations(self) -> conversations.ConversationsResourceWithRawResponse: from .resources.conversations import ConversationsResourceWithRawResponse @@ -897,6 +917,12 @@ def responses(self) -> responses.AsyncResponsesResourceWithRawResponse: return AsyncResponsesResourceWithRawResponse(self._client.responses) + @cached_property + def prompts(self) -> prompts.AsyncPromptsResourceWithRawResponse: + from .resources.prompts import AsyncPromptsResourceWithRawResponse + + return AsyncPromptsResourceWithRawResponse(self._client.prompts) + @cached_property def conversations(self) -> conversations.AsyncConversationsResourceWithRawResponse: from .resources.conversations import AsyncConversationsResourceWithRawResponse @@ -1044,6 +1070,12 @@ def responses(self) -> responses.ResponsesResourceWithStreamingResponse: return ResponsesResourceWithStreamingResponse(self._client.responses) + @cached_property + def prompts(self) -> prompts.PromptsResourceWithStreamingResponse: + from .resources.prompts import PromptsResourceWithStreamingResponse + + return PromptsResourceWithStreamingResponse(self._client.prompts) + @cached_property def conversations(self) -> conversations.ConversationsResourceWithStreamingResponse: from .resources.conversations import ConversationsResourceWithStreamingResponse @@ -1191,6 +1223,12 @@ def responses(self) -> responses.AsyncResponsesResourceWithStreamingResponse: return AsyncResponsesResourceWithStreamingResponse(self._client.responses) + @cached_property + def prompts(self) -> prompts.AsyncPromptsResourceWithStreamingResponse: + from .resources.prompts import AsyncPromptsResourceWithStreamingResponse + + return AsyncPromptsResourceWithStreamingResponse(self._client.prompts) + @cached_property def conversations(self) -> conversations.AsyncConversationsResourceWithStreamingResponse: from .resources.conversations import AsyncConversationsResourceWithStreamingResponse diff --git a/src/llama_stack_client/_streaming.py b/src/llama_stack_client/_streaming.py index 5f23d84d..e732cb57 100644 --- a/src/llama_stack_client/_streaming.py +++ b/src/llama_stack_client/_streaming.py @@ -63,9 +63,8 @@ def __stream__(self) -> Iterator[_T]: for sse in iterator: yield process_data(data=sse.json(), cast_to=cast_to, response=response) - # Ensure the entire stream is consumed - for _sse in iterator: - ... + # As we might not fully consume the response stream, we need to close it explicitly + response.close() def __enter__(self) -> Self: return self @@ -127,9 +126,8 @@ async def __stream__(self) -> AsyncIterator[_T]: async for sse in iterator: yield process_data(data=sse.json(), cast_to=cast_to, response=response) - # Ensure the entire stream is consumed - async for _sse in iterator: - ... + # As we might not fully consume the response stream, we need to close it explicitly + await response.aclose() async def __aenter__(self) -> Self: return self diff --git a/src/llama_stack_client/resources/__init__.py b/src/llama_stack_client/resources/__init__.py index 60b18979..807ed6c8 100644 --- a/src/llama_stack_client/resources/__init__.py +++ b/src/llama_stack_client/resources/__init__.py @@ -78,6 +78,14 @@ InspectResourceWithStreamingResponse, AsyncInspectResourceWithStreamingResponse, ) +from .prompts import ( + PromptsResource, + AsyncPromptsResource, + PromptsResourceWithRawResponse, + AsyncPromptsResourceWithRawResponse, + PromptsResourceWithStreamingResponse, + AsyncPromptsResourceWithStreamingResponse, +) from .scoring import ( ScoringResource, AsyncScoringResource, @@ -216,6 +224,12 @@ "AsyncResponsesResourceWithRawResponse", "ResponsesResourceWithStreamingResponse", "AsyncResponsesResourceWithStreamingResponse", + "PromptsResource", + "AsyncPromptsResource", + "PromptsResourceWithRawResponse", + "AsyncPromptsResourceWithRawResponse", + "PromptsResourceWithStreamingResponse", + "AsyncPromptsResourceWithStreamingResponse", "ConversationsResource", "AsyncConversationsResource", "ConversationsResourceWithRawResponse", diff --git a/src/llama_stack_client/resources/prompts/__init__.py b/src/llama_stack_client/resources/prompts/__init__.py new file mode 100644 index 00000000..d8c5c535 --- /dev/null +++ b/src/llama_stack_client/resources/prompts/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .prompts import ( + PromptsResource, + AsyncPromptsResource, + PromptsResourceWithRawResponse, + AsyncPromptsResourceWithRawResponse, + PromptsResourceWithStreamingResponse, + AsyncPromptsResourceWithStreamingResponse, +) +from .versions import ( + VersionsResource, + AsyncVersionsResource, + VersionsResourceWithRawResponse, + AsyncVersionsResourceWithRawResponse, + VersionsResourceWithStreamingResponse, + AsyncVersionsResourceWithStreamingResponse, +) + +__all__ = [ + "VersionsResource", + "AsyncVersionsResource", + "VersionsResourceWithRawResponse", + "AsyncVersionsResourceWithRawResponse", + "VersionsResourceWithStreamingResponse", + "AsyncVersionsResourceWithStreamingResponse", + "PromptsResource", + "AsyncPromptsResource", + "PromptsResourceWithRawResponse", + "AsyncPromptsResourceWithRawResponse", + "PromptsResourceWithStreamingResponse", + "AsyncPromptsResourceWithStreamingResponse", +] diff --git a/src/llama_stack_client/resources/prompts/prompts.py b/src/llama_stack_client/resources/prompts/prompts.py new file mode 100644 index 00000000..aa14c6f2 --- /dev/null +++ b/src/llama_stack_client/resources/prompts/prompts.py @@ -0,0 +1,676 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Type, cast + +import httpx + +from ...types import ( + prompt_create_params, + prompt_update_params, + prompt_retrieve_params, + prompt_set_default_version_params, +) +from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, omit, not_given +from ..._utils import maybe_transform, async_maybe_transform +from .versions import ( + VersionsResource, + AsyncVersionsResource, + VersionsResourceWithRawResponse, + AsyncVersionsResourceWithRawResponse, + VersionsResourceWithStreamingResponse, + AsyncVersionsResourceWithStreamingResponse, +) +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 ..._wrappers import DataWrapper +from ..._base_client import make_request_options +from ...types.prompt import Prompt +from ...types.prompt_list_response import PromptListResponse + +__all__ = ["PromptsResource", "AsyncPromptsResource"] + + +class PromptsResource(SyncAPIResource): + @cached_property + def versions(self) -> VersionsResource: + return VersionsResource(self._client) + + @cached_property + def with_raw_response(self) -> PromptsResourceWithRawResponse: + """ + 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/llamastack/llama-stack-client-python#accessing-raw-response-data-eg-headers + """ + return PromptsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PromptsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/llamastack/llama-stack-client-python#with_streaming_response + """ + return PromptsResourceWithStreamingResponse(self) + + def create( + self, + *, + prompt: str, + variables: SequenceNotStr[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, + ) -> Prompt: + """Create prompt. + + Create a new prompt. + + Args: + prompt: The prompt text content with variable placeholders. + + variables: List of variable names that can be used in the prompt template. + + 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 + """ + return self._post( + "/v1/prompts", + body=maybe_transform( + { + "prompt": prompt, + "variables": variables, + }, + prompt_create_params.PromptCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + def retrieve( + self, + prompt_id: str, + *, + version: int | 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, + ) -> Prompt: + """Get prompt. + + Get a prompt by its identifier and optional version. + + Args: + version: The version of the prompt to get (defaults to latest). + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return self._get( + f"/v1/prompts/{prompt_id}", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"version": version}, prompt_retrieve_params.PromptRetrieveParams), + ), + cast_to=Prompt, + ) + + def update( + self, + prompt_id: str, + *, + prompt: str, + set_as_default: bool, + version: int, + variables: SequenceNotStr[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, + ) -> Prompt: + """Update prompt. + + Update an existing prompt (increments version). + + Args: + prompt: The updated prompt text content. + + set_as_default: Set the new version as the default (default=True). + + version: The current version of the prompt being updated. + + variables: Updated list of variable names that can be used in the prompt template. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return self._post( + f"/v1/prompts/{prompt_id}", + body=maybe_transform( + { + "prompt": prompt, + "set_as_default": set_as_default, + "version": version, + "variables": variables, + }, + prompt_update_params.PromptUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + 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, + ) -> PromptListResponse: + """List all prompts.""" + return self._get( + "/v1/prompts", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=DataWrapper[PromptListResponse]._unwrapper, + ), + cast_to=cast(Type[PromptListResponse], DataWrapper[PromptListResponse]), + ) + + def delete( + self, + prompt_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 prompt. + + Delete a prompt. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return self._delete( + f"/v1/prompts/{prompt_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + def set_default_version( + self, + prompt_id: str, + *, + version: int, + # 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, + ) -> Prompt: + """Set prompt version. + + Set which version of a prompt should be the default in + get_prompt (latest). + + Args: + version: The version to set as default. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return self._post( + f"/v1/prompts/{prompt_id}/set-default-version", + body=maybe_transform({"version": version}, prompt_set_default_version_params.PromptSetDefaultVersionParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + +class AsyncPromptsResource(AsyncAPIResource): + @cached_property + def versions(self) -> AsyncVersionsResource: + return AsyncVersionsResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncPromptsResourceWithRawResponse: + """ + 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/llamastack/llama-stack-client-python#accessing-raw-response-data-eg-headers + """ + return AsyncPromptsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPromptsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/llamastack/llama-stack-client-python#with_streaming_response + """ + return AsyncPromptsResourceWithStreamingResponse(self) + + async def create( + self, + *, + prompt: str, + variables: SequenceNotStr[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, + ) -> Prompt: + """Create prompt. + + Create a new prompt. + + Args: + prompt: The prompt text content with variable placeholders. + + variables: List of variable names that can be used in the prompt template. + + 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 + """ + return await self._post( + "/v1/prompts", + body=await async_maybe_transform( + { + "prompt": prompt, + "variables": variables, + }, + prompt_create_params.PromptCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + async def retrieve( + self, + prompt_id: str, + *, + version: int | 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, + ) -> Prompt: + """Get prompt. + + Get a prompt by its identifier and optional version. + + Args: + version: The version of the prompt to get (defaults to latest). + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return await self._get( + f"/v1/prompts/{prompt_id}", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform({"version": version}, prompt_retrieve_params.PromptRetrieveParams), + ), + cast_to=Prompt, + ) + + async def update( + self, + prompt_id: str, + *, + prompt: str, + set_as_default: bool, + version: int, + variables: SequenceNotStr[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, + ) -> Prompt: + """Update prompt. + + Update an existing prompt (increments version). + + Args: + prompt: The updated prompt text content. + + set_as_default: Set the new version as the default (default=True). + + version: The current version of the prompt being updated. + + variables: Updated list of variable names that can be used in the prompt template. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return await self._post( + f"/v1/prompts/{prompt_id}", + body=await async_maybe_transform( + { + "prompt": prompt, + "set_as_default": set_as_default, + "version": version, + "variables": variables, + }, + prompt_update_params.PromptUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + 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, + ) -> PromptListResponse: + """List all prompts.""" + return await self._get( + "/v1/prompts", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=DataWrapper[PromptListResponse]._unwrapper, + ), + cast_to=cast(Type[PromptListResponse], DataWrapper[PromptListResponse]), + ) + + async def delete( + self, + prompt_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 prompt. + + Delete a prompt. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + extra_headers = {"Accept": "*/*", **(extra_headers or {})} + return await self._delete( + f"/v1/prompts/{prompt_id}", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=NoneType, + ) + + async def set_default_version( + self, + prompt_id: str, + *, + version: int, + # 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, + ) -> Prompt: + """Set prompt version. + + Set which version of a prompt should be the default in + get_prompt (latest). + + Args: + version: The version to set as default. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return await self._post( + f"/v1/prompts/{prompt_id}/set-default-version", + body=await async_maybe_transform( + {"version": version}, prompt_set_default_version_params.PromptSetDefaultVersionParams + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Prompt, + ) + + +class PromptsResourceWithRawResponse: + def __init__(self, prompts: PromptsResource) -> None: + self._prompts = prompts + + self.create = to_raw_response_wrapper( + prompts.create, + ) + self.retrieve = to_raw_response_wrapper( + prompts.retrieve, + ) + self.update = to_raw_response_wrapper( + prompts.update, + ) + self.list = to_raw_response_wrapper( + prompts.list, + ) + self.delete = to_raw_response_wrapper( + prompts.delete, + ) + self.set_default_version = to_raw_response_wrapper( + prompts.set_default_version, + ) + + @cached_property + def versions(self) -> VersionsResourceWithRawResponse: + return VersionsResourceWithRawResponse(self._prompts.versions) + + +class AsyncPromptsResourceWithRawResponse: + def __init__(self, prompts: AsyncPromptsResource) -> None: + self._prompts = prompts + + self.create = async_to_raw_response_wrapper( + prompts.create, + ) + self.retrieve = async_to_raw_response_wrapper( + prompts.retrieve, + ) + self.update = async_to_raw_response_wrapper( + prompts.update, + ) + self.list = async_to_raw_response_wrapper( + prompts.list, + ) + self.delete = async_to_raw_response_wrapper( + prompts.delete, + ) + self.set_default_version = async_to_raw_response_wrapper( + prompts.set_default_version, + ) + + @cached_property + def versions(self) -> AsyncVersionsResourceWithRawResponse: + return AsyncVersionsResourceWithRawResponse(self._prompts.versions) + + +class PromptsResourceWithStreamingResponse: + def __init__(self, prompts: PromptsResource) -> None: + self._prompts = prompts + + self.create = to_streamed_response_wrapper( + prompts.create, + ) + self.retrieve = to_streamed_response_wrapper( + prompts.retrieve, + ) + self.update = to_streamed_response_wrapper( + prompts.update, + ) + self.list = to_streamed_response_wrapper( + prompts.list, + ) + self.delete = to_streamed_response_wrapper( + prompts.delete, + ) + self.set_default_version = to_streamed_response_wrapper( + prompts.set_default_version, + ) + + @cached_property + def versions(self) -> VersionsResourceWithStreamingResponse: + return VersionsResourceWithStreamingResponse(self._prompts.versions) + + +class AsyncPromptsResourceWithStreamingResponse: + def __init__(self, prompts: AsyncPromptsResource) -> None: + self._prompts = prompts + + self.create = async_to_streamed_response_wrapper( + prompts.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + prompts.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + prompts.update, + ) + self.list = async_to_streamed_response_wrapper( + prompts.list, + ) + self.delete = async_to_streamed_response_wrapper( + prompts.delete, + ) + self.set_default_version = async_to_streamed_response_wrapper( + prompts.set_default_version, + ) + + @cached_property + def versions(self) -> AsyncVersionsResourceWithStreamingResponse: + return AsyncVersionsResourceWithStreamingResponse(self._prompts.versions) diff --git a/src/llama_stack_client/resources/prompts/versions.py b/src/llama_stack_client/resources/prompts/versions.py new file mode 100644 index 00000000..bf074dc7 --- /dev/null +++ b/src/llama_stack_client/resources/prompts/versions.py @@ -0,0 +1,176 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Type, cast + +import httpx + +from ..._types import Body, Query, Headers, NotGiven, not_given +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 ..._wrappers import DataWrapper +from ..._base_client import make_request_options +from ...types.prompt_list_response import PromptListResponse + +__all__ = ["VersionsResource", "AsyncVersionsResource"] + + +class VersionsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> VersionsResourceWithRawResponse: + """ + 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/llamastack/llama-stack-client-python#accessing-raw-response-data-eg-headers + """ + return VersionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VersionsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/llamastack/llama-stack-client-python#with_streaming_response + """ + return VersionsResourceWithStreamingResponse(self) + + def list( + self, + prompt_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, + ) -> PromptListResponse: + """List prompt versions. + + List all versions of a specific prompt. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return self._get( + f"/v1/prompts/{prompt_id}/versions", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=DataWrapper[PromptListResponse]._unwrapper, + ), + cast_to=cast(Type[PromptListResponse], DataWrapper[PromptListResponse]), + ) + + +class AsyncVersionsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncVersionsResourceWithRawResponse: + """ + 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/llamastack/llama-stack-client-python#accessing-raw-response-data-eg-headers + """ + return AsyncVersionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVersionsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/llamastack/llama-stack-client-python#with_streaming_response + """ + return AsyncVersionsResourceWithStreamingResponse(self) + + async def list( + self, + prompt_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, + ) -> PromptListResponse: + """List prompt versions. + + List all versions of a specific prompt. + + 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 prompt_id: + raise ValueError(f"Expected a non-empty value for `prompt_id` but received {prompt_id!r}") + return await self._get( + f"/v1/prompts/{prompt_id}/versions", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=DataWrapper[PromptListResponse]._unwrapper, + ), + cast_to=cast(Type[PromptListResponse], DataWrapper[PromptListResponse]), + ) + + +class VersionsResourceWithRawResponse: + def __init__(self, versions: VersionsResource) -> None: + self._versions = versions + + self.list = to_raw_response_wrapper( + versions.list, + ) + + +class AsyncVersionsResourceWithRawResponse: + def __init__(self, versions: AsyncVersionsResource) -> None: + self._versions = versions + + self.list = async_to_raw_response_wrapper( + versions.list, + ) + + +class VersionsResourceWithStreamingResponse: + def __init__(self, versions: VersionsResource) -> None: + self._versions = versions + + self.list = to_streamed_response_wrapper( + versions.list, + ) + + +class AsyncVersionsResourceWithStreamingResponse: + def __init__(self, versions: AsyncVersionsResource) -> None: + self._versions = versions + + self.list = async_to_streamed_response_wrapper( + versions.list, + ) diff --git a/src/llama_stack_client/types/__init__.py b/src/llama_stack_client/types/__init__.py index 173a1e03..4b6a2b84 100644 --- a/src/llama_stack_client/types/__init__.py +++ b/src/llama_stack_client/types/__init__.py @@ -10,6 +10,7 @@ from .file import File as File from .model import Model as Model +from .prompt import Prompt as Prompt from .shared import ( Message as Message, Document as Document, @@ -54,13 +55,18 @@ from .delete_file_response import DeleteFileResponse as DeleteFileResponse from .list_models_response import ListModelsResponse as ListModelsResponse from .list_routes_response import ListRoutesResponse as ListRoutesResponse +from .prompt_create_params import PromptCreateParams as PromptCreateParams +from .prompt_list_response import PromptListResponse as PromptListResponse +from .prompt_update_params import PromptUpdateParams as PromptUpdateParams from .response_list_params import ResponseListParams as ResponseListParams from .scoring_score_params import ScoringScoreParams as ScoringScoreParams from .shield_list_response import ShieldListResponse as ShieldListResponse from .chat_completion_chunk import ChatCompletionChunk as ChatCompletionChunk +from .list_prompts_response import ListPromptsResponse as ListPromptsResponse from .list_shields_response import ListShieldsResponse as ListShieldsResponse from .model_register_params import ModelRegisterParams as ModelRegisterParams from .query_chunks_response import QueryChunksResponse as QueryChunksResponse +from .prompt_retrieve_params import PromptRetrieveParams as PromptRetrieveParams from .provider_list_response import ProviderListResponse as ProviderListResponse from .response_create_params import ResponseCreateParams as ResponseCreateParams from .response_list_response import ResponseListResponse as ResponseListResponse @@ -100,6 +106,7 @@ from .tool_runtime_invoke_tool_params import ToolRuntimeInvokeToolParams as ToolRuntimeInvokeToolParams from .scoring_function_register_params import ScoringFunctionRegisterParams as ScoringFunctionRegisterParams from .tool_runtime_list_tools_response import ToolRuntimeListToolsResponse as ToolRuntimeListToolsResponse +from .prompt_set_default_version_params import PromptSetDefaultVersionParams as PromptSetDefaultVersionParams from .synthetic_data_generation_response import SyntheticDataGenerationResponse as SyntheticDataGenerationResponse from .synthetic_data_generation_generate_params import ( SyntheticDataGenerationGenerateParams as SyntheticDataGenerationGenerateParams, diff --git a/src/llama_stack_client/types/list_prompts_response.py b/src/llama_stack_client/types/list_prompts_response.py new file mode 100644 index 00000000..cc5058d3 --- /dev/null +++ b/src/llama_stack_client/types/list_prompts_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .._models import BaseModel +from .prompt_list_response import PromptListResponse + +__all__ = ["ListPromptsResponse"] + + +class ListPromptsResponse(BaseModel): + data: PromptListResponse diff --git a/src/llama_stack_client/types/prompt.py b/src/llama_stack_client/types/prompt.py new file mode 100644 index 00000000..f88c74ad --- /dev/null +++ b/src/llama_stack_client/types/prompt.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from .._models import BaseModel + +__all__ = ["Prompt"] + + +class Prompt(BaseModel): + is_default: bool + """Boolean indicating whether this version is the default version for this prompt""" + + prompt_id: str + """Unique identifier formatted as 'pmpt\\__<48-digit-hash>'""" + + variables: List[str] + """List of prompt variable names that can be used in the prompt template""" + + version: int + """Version (integer starting at 1, incremented on save)""" + + prompt: Optional[str] = None + """The system prompt text with variable placeholders. + + Variables are only supported when using the Responses API. + """ diff --git a/src/llama_stack_client/types/prompt_create_params.py b/src/llama_stack_client/types/prompt_create_params.py new file mode 100644 index 00000000..a1c2b411 --- /dev/null +++ b/src/llama_stack_client/types/prompt_create_params.py @@ -0,0 +1,17 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +from .._types import SequenceNotStr + +__all__ = ["PromptCreateParams"] + + +class PromptCreateParams(TypedDict, total=False): + prompt: Required[str] + """The prompt text content with variable placeholders.""" + + variables: SequenceNotStr[str] + """List of variable names that can be used in the prompt template.""" diff --git a/src/llama_stack_client/types/prompt_list_response.py b/src/llama_stack_client/types/prompt_list_response.py new file mode 100644 index 00000000..37ac9b55 --- /dev/null +++ b/src/llama_stack_client/types/prompt_list_response.py @@ -0,0 +1,10 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List +from typing_extensions import TypeAlias + +from .prompt import Prompt + +__all__ = ["PromptListResponse"] + +PromptListResponse: TypeAlias = List[Prompt] diff --git a/src/llama_stack_client/types/prompt_retrieve_params.py b/src/llama_stack_client/types/prompt_retrieve_params.py new file mode 100644 index 00000000..71674dd2 --- /dev/null +++ b/src/llama_stack_client/types/prompt_retrieve_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import TypedDict + +__all__ = ["PromptRetrieveParams"] + + +class PromptRetrieveParams(TypedDict, total=False): + version: int + """The version of the prompt to get (defaults to latest).""" diff --git a/src/llama_stack_client/types/prompt_set_default_version_params.py b/src/llama_stack_client/types/prompt_set_default_version_params.py new file mode 100644 index 00000000..6b5c6130 --- /dev/null +++ b/src/llama_stack_client/types/prompt_set_default_version_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["PromptSetDefaultVersionParams"] + + +class PromptSetDefaultVersionParams(TypedDict, total=False): + version: Required[int] + """The version to set as default.""" diff --git a/src/llama_stack_client/types/prompt_update_params.py b/src/llama_stack_client/types/prompt_update_params.py new file mode 100644 index 00000000..9753a07a --- /dev/null +++ b/src/llama_stack_client/types/prompt_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 Required, TypedDict + +from .._types import SequenceNotStr + +__all__ = ["PromptUpdateParams"] + + +class PromptUpdateParams(TypedDict, total=False): + prompt: Required[str] + """The updated prompt text content.""" + + set_as_default: Required[bool] + """Set the new version as the default (default=True).""" + + version: Required[int] + """The current version of the prompt being updated.""" + + variables: SequenceNotStr[str] + """Updated list of variable names that can be used in the prompt template.""" diff --git a/src/llama_stack_client/types/prompts/__init__.py b/src/llama_stack_client/types/prompts/__init__.py new file mode 100644 index 00000000..f8ee8b14 --- /dev/null +++ b/src/llama_stack_client/types/prompts/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations diff --git a/tests/api_resources/prompts/__init__.py b/tests/api_resources/prompts/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/prompts/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/prompts/test_versions.py b/tests/api_resources/prompts/test_versions.py new file mode 100644 index 00000000..2955203b --- /dev/null +++ b/tests/api_resources/prompts/test_versions.py @@ -0,0 +1,100 @@ +# 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 llama_stack_client import LlamaStackClient, AsyncLlamaStackClient +from llama_stack_client.types import PromptListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestVersions: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_list(self, client: LlamaStackClient) -> None: + version = client.prompts.versions.list( + "prompt_id", + ) + assert_matches_type(PromptListResponse, version, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: LlamaStackClient) -> None: + response = client.prompts.versions.with_raw_response.list( + "prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + version = response.parse() + assert_matches_type(PromptListResponse, version, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: LlamaStackClient) -> None: + with client.prompts.versions.with_streaming_response.list( + "prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + version = response.parse() + assert_matches_type(PromptListResponse, version, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_list(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + client.prompts.versions.with_raw_response.list( + "", + ) + + +class TestAsyncVersions: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @parametrize + async def test_method_list(self, async_client: AsyncLlamaStackClient) -> None: + version = await async_client.prompts.versions.list( + "prompt_id", + ) + assert_matches_type(PromptListResponse, version, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.versions.with_raw_response.list( + "prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + version = await response.parse() + assert_matches_type(PromptListResponse, version, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.versions.with_streaming_response.list( + "prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + version = await response.parse() + assert_matches_type(PromptListResponse, version, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_list(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + await async_client.prompts.versions.with_raw_response.list( + "", + ) diff --git a/tests/api_resources/test_prompts.py b/tests/api_resources/test_prompts.py new file mode 100644 index 00000000..f09af45c --- /dev/null +++ b/tests/api_resources/test_prompts.py @@ -0,0 +1,529 @@ +# 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 llama_stack_client import LlamaStackClient, AsyncLlamaStackClient +from llama_stack_client.types import ( + Prompt, + PromptListResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestPrompts: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: LlamaStackClient) -> None: + prompt = client.prompts.create( + prompt="prompt", + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_method_create_with_all_params(self, client: LlamaStackClient) -> None: + prompt = client.prompts.create( + prompt="prompt", + variables=["string"], + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_raw_response_create(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.create( + prompt="prompt", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_streaming_response_create(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.create( + prompt="prompt", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_retrieve(self, client: LlamaStackClient) -> None: + prompt = client.prompts.retrieve( + prompt_id="prompt_id", + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_method_retrieve_with_all_params(self, client: LlamaStackClient) -> None: + prompt = client.prompts.retrieve( + prompt_id="prompt_id", + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_raw_response_retrieve(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.retrieve( + prompt_id="prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_streaming_response_retrieve(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.retrieve( + prompt_id="prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_retrieve(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + client.prompts.with_raw_response.retrieve( + prompt_id="", + ) + + @parametrize + def test_method_update(self, client: LlamaStackClient) -> None: + prompt = client.prompts.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_method_update_with_all_params(self, client: LlamaStackClient) -> None: + prompt = client.prompts.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + variables=["string"], + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_raw_response_update(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_streaming_response_update(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_update(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + client.prompts.with_raw_response.update( + prompt_id="", + prompt="prompt", + set_as_default=True, + version=0, + ) + + @parametrize + def test_method_list(self, client: LlamaStackClient) -> None: + prompt = client.prompts.list() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_delete(self, client: LlamaStackClient) -> None: + prompt = client.prompts.delete( + "prompt_id", + ) + assert prompt is None + + @parametrize + def test_raw_response_delete(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.delete( + "prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert prompt is None + + @parametrize + def test_streaming_response_delete(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.delete( + "prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert prompt is None + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_delete(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + client.prompts.with_raw_response.delete( + "", + ) + + @parametrize + def test_method_set_default_version(self, client: LlamaStackClient) -> None: + prompt = client.prompts.set_default_version( + prompt_id="prompt_id", + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_raw_response_set_default_version(self, client: LlamaStackClient) -> None: + response = client.prompts.with_raw_response.set_default_version( + prompt_id="prompt_id", + version=0, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + def test_streaming_response_set_default_version(self, client: LlamaStackClient) -> None: + with client.prompts.with_streaming_response.set_default_version( + prompt_id="prompt_id", + version=0, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_set_default_version(self, client: LlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + client.prompts.with_raw_response.set_default_version( + prompt_id="", + version=0, + ) + + +class TestAsyncPrompts: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @parametrize + async def test_method_create(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.create( + prompt="prompt", + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.create( + prompt="prompt", + variables=["string"], + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_raw_response_create(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.create( + prompt="prompt", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.create( + prompt="prompt", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_retrieve(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.retrieve( + prompt_id="prompt_id", + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.retrieve( + prompt_id="prompt_id", + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.retrieve( + prompt_id="prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.retrieve( + prompt_id="prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + await async_client.prompts.with_raw_response.retrieve( + prompt_id="", + ) + + @parametrize + async def test_method_update(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + variables=["string"], + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_raw_response_update(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_streaming_response_update(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.update( + prompt_id="prompt_id", + prompt="prompt", + set_as_default=True, + version=0, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_update(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + await async_client.prompts.with_raw_response.update( + prompt_id="", + prompt="prompt", + set_as_default=True, + version=0, + ) + + @parametrize + async def test_method_list(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.list() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert_matches_type(PromptListResponse, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_delete(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.delete( + "prompt_id", + ) + assert prompt is None + + @parametrize + async def test_raw_response_delete(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.delete( + "prompt_id", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert prompt is None + + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.delete( + "prompt_id", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert prompt is None + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_delete(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + await async_client.prompts.with_raw_response.delete( + "", + ) + + @parametrize + async def test_method_set_default_version(self, async_client: AsyncLlamaStackClient) -> None: + prompt = await async_client.prompts.set_default_version( + prompt_id="prompt_id", + version=0, + ) + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_raw_response_set_default_version(self, async_client: AsyncLlamaStackClient) -> None: + response = await async_client.prompts.with_raw_response.set_default_version( + prompt_id="prompt_id", + version=0, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + @parametrize + async def test_streaming_response_set_default_version(self, async_client: AsyncLlamaStackClient) -> None: + async with async_client.prompts.with_streaming_response.set_default_version( + prompt_id="prompt_id", + version=0, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + prompt = await response.parse() + assert_matches_type(Prompt, prompt, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_set_default_version(self, async_client: AsyncLlamaStackClient) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `prompt_id` but received ''"): + await async_client.prompts.with_raw_response.set_default_version( + prompt_id="", + version=0, + )