feat(client): add support for model queries

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 29
+configured_endpoints: 30
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/replicate%2Freplicate-client-2788217b7ad7d61d1a77800bc5ff12a6810f1692d4d770b72fa8f898c6a055ab.yml
 openapi_spec_hash: 4423bf747e228484547b441468a9f156
-config_hash: f4b37a468a2e67394c9d35f080d37c51
+config_hash: 2e6a171ce57a4a6a8e8dcd3dd893d8cc

api.md

@@ -70,6 +70,7 @@ Methods:
 - <code title="get /models">client.models.<a href="./src/replicate/resources/models/models.py">list</a>() -> <a href="./src/replicate/types/model_list_response.py">SyncCursorURLPage[ModelListResponse]</a></code>
 - <code title="delete /models/{model_owner}/{model_name}">client.models.<a href="./src/replicate/resources/models/models.py">delete</a>(model_name, \*, model_owner) -> None</code>
 - <code title="get /models/{model_owner}/{model_name}">client.models.<a href="./src/replicate/resources/models/models.py">get</a>(model_name, \*, model_owner) -> None</code>
+- <code title="query /models">client.models.<a href="./src/replicate/resources/models/models.py">search</a>(\*\*<a href="src/replicate/types/model_search_params.py">params</a>) -> None</code>
 
 ## Examples
 

src/replicate/_base_client.py

@@ -1221,6 +1221,20 @@ def post(
         )
         return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))
 
+    def query(
+        self,
+        path: str,
+        *,
+        cast_to: Type[ResponseT],
+        body: Body | None = None,
+        options: RequestOptions = {},
+        files: RequestFiles | None = None,
+    ) -> ResponseT:
+        opts = FinalRequestOptions.construct(
+            method="query", url=path, json_data=body, files=to_httpx_files(files), **options
+        )
+        return self.request(cast_to, opts)
+
     def patch(
         self,
         path: str,
@@ -1709,6 +1723,20 @@ async def post(
         )
         return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)
 
+    async def query(
+        self,
+        path: str,
+        *,
+        cast_to: Type[ResponseT],
+        body: Body | None = None,
+        options: RequestOptions = {},
+        files: RequestFiles | None = None,
+    ) -> ResponseT:
+        opts = FinalRequestOptions.construct(
+            method="query", url=path, json_data=body, files=await async_to_httpx_files(files), **options
+        )
+        return await self.request(cast_to, opts)
+
     async def patch(
         self,
         path: str,

src/replicate/_resource.py

@@ -22,6 +22,7 @@ def __init__(self, client: ReplicateClient) -> None:
         self._put = client.put
         self._delete = client.delete
         self._get_api_list = client.get_api_list
+        self._query = client.query
 
     def _sleep(self, seconds: float) -> None:
         time.sleep(seconds)
@@ -38,6 +39,7 @@ def __init__(self, client: AsyncReplicateClient) -> None:
         self._put = client.put
         self._delete = client.delete
         self._get_api_list = client.get_api_list
+        self._query = client.query
 
     async def _sleep(self, seconds: float) -> None:
         await anyio.sleep(seconds)

src/replicate/resources/models/models.py

@@ -14,7 +14,7 @@
     ReadmeResourceWithStreamingResponse,
     AsyncReadmeResourceWithStreamingResponse,
 )
-from ...types import model_create_params
+from ...types import model_create_params, model_search_params
 from ..._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
 from ..._utils import maybe_transform, async_maybe_transform
 from .examples import (
@@ -404,6 +404,57 @@ def get(
             cast_to=NoneType,
         )
 
+    def search(
+        self,
+        *,
+        body: 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:
+        """
+        Get a list of public models matching a search query.
+
+        Example cURL request:
+
+        ```console
+        curl -s -X QUERY \\
+          -H "Authorization: Bearer $REPLICATE_API_TOKEN" \\
+          -H "Content-Type: text/plain" \\
+          -d "hello" \\
+          https://api.replicate.com/v1/models
+        ```
+
+        The response will be a paginated JSON object containing an array of model
+        objects.
+
+        See the [`models.get`](#models.get) docs for more details about the model
+        object.
+
+        Args:
+          body: The search query
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._query(
+            "/models",
+            body=maybe_transform(body, model_search_params.ModelSearchParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
 
 class AsyncModelsResource(AsyncAPIResource):
     @cached_property
@@ -753,6 +804,57 @@ async def get(
             cast_to=NoneType,
         )
 
+    async def search(
+        self,
+        *,
+        body: 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:
+        """
+        Get a list of public models matching a search query.
+
+        Example cURL request:
+
+        ```console
+        curl -s -X QUERY \\
+          -H "Authorization: Bearer $REPLICATE_API_TOKEN" \\
+          -H "Content-Type: text/plain" \\
+          -d "hello" \\
+          https://api.replicate.com/v1/models
+        ```
+
+        The response will be a paginated JSON object containing an array of model
+        objects.
+
+        See the [`models.get`](#models.get) docs for more details about the model
+        object.
+
+        Args:
+          body: The search query
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._query(
+            "/models",
+            body=await async_maybe_transform(body, model_search_params.ModelSearchParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
 
 class ModelsResourceWithRawResponse:
     def __init__(self, models: ModelsResource) -> None:
@@ -770,6 +872,9 @@ def __init__(self, models: ModelsResource) -> None:
         self.get = to_raw_response_wrapper(
             models.get,
         )
+        self.search = to_raw_response_wrapper(
+            models.search,
+        )
 
     @cached_property
     def examples(self) -> ExamplesResourceWithRawResponse:
@@ -804,6 +909,9 @@ def __init__(self, models: AsyncModelsResource) -> None:
         self.get = async_to_raw_response_wrapper(
             models.get,
         )
+        self.search = async_to_raw_response_wrapper(
+            models.search,
+        )
 
     @cached_property
     def examples(self) -> AsyncExamplesResourceWithRawResponse:
@@ -838,6 +946,9 @@ def __init__(self, models: ModelsResource) -> None:
         self.get = to_streamed_response_wrapper(
             models.get,
         )
+        self.search = to_streamed_response_wrapper(
+            models.search,
+        )
 
     @cached_property
     def examples(self) -> ExamplesResourceWithStreamingResponse:
@@ -872,6 +983,9 @@ def __init__(self, models: AsyncModelsResource) -> None:
         self.get = async_to_streamed_response_wrapper(
             models.get,
         )
+        self.search = async_to_streamed_response_wrapper(
+            models.search,
+        )
 
     @cached_property
     def examples(self) -> AsyncExamplesResourceWithStreamingResponse:

src/replicate/types/__init__.py

@@ -6,6 +6,7 @@
 from .prediction_output import PredictionOutput as PredictionOutput
 from .model_create_params import ModelCreateParams as ModelCreateParams
 from .model_list_response import ModelListResponse as ModelListResponse
+from .model_search_params import ModelSearchParams as ModelSearchParams
 from .account_get_response import AccountGetResponse as AccountGetResponse
 from .training_get_response import TrainingGetResponse as TrainingGetResponse
 from .hardware_list_response import HardwareListResponse as HardwareListResponse

src/replicate/types/model_search_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__ = ["ModelSearchParams"]
+
+
+class ModelSearchParams(TypedDict, total=False):
+    body: Required[str]
+    """The search query"""

tests/api_resources/test_models.py

@@ -209,6 +209,40 @@ def test_path_params_get(self, client: ReplicateClient) -> None:
                 model_owner="model_owner",
             )
 
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    def test_method_search(self, client: ReplicateClient) -> None:
+        model = client.models.search(
+            body="body",
+        )
+        assert model is None
+
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    def test_raw_response_search(self, client: ReplicateClient) -> None:
+        response = client.models.with_raw_response.search(
+            body="body",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        model = response.parse()
+        assert model is None
+
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    def test_streaming_response_search(self, client: ReplicateClient) -> None:
+        with client.models.with_streaming_response.search(
+            body="body",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            model = response.parse()
+            assert model is None
+
+        assert cast(Any, response.is_closed) is True
+
 
 class TestAsyncModels:
     parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@@ -403,3 +437,37 @@ async def test_path_params_get(self, async_client: AsyncReplicateClient) -> None
                 model_name="",
                 model_owner="model_owner",
             )
+
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    async def test_method_search(self, async_client: AsyncReplicateClient) -> None:
+        model = await async_client.models.search(
+            body="body",
+        )
+        assert model is None
+
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    async def test_raw_response_search(self, async_client: AsyncReplicateClient) -> None:
+        response = await async_client.models.with_raw_response.search(
+            body="body",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        model = await response.parse()
+        assert model is None
+
+    @pytest.mark.skip(reason="Prism doesn't support query methods yet")
+    @parametrize
+    async def test_streaming_response_search(self, async_client: AsyncReplicateClient) -> None:
+        async with async_client.models.with_streaming_response.search(
+            body="body",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            model = await response.parse()
+            assert model is None
+
+        assert cast(Any, response.is_closed) is True