feat(api): update via SDK Studio (#5)

Author: stainless-app[bot]

api.md

@@ -44,8 +44,8 @@ from replicate.types import HardwareListResponse
 
 Methods:
 
-- <code title="get /collections/{collection_slug}">client.hardware.<a href="./src/replicate/resources/hardware.py">retrieve</a>(collection_slug) -> None</code>
 - <code title="get /hardware">client.hardware.<a href="./src/replicate/resources/hardware.py">list</a>() -> <a href="./src/replicate/types/hardware_list_response.py">HardwareListResponse</a></code>
+- <code title="get /collections/{collection_slug}">client.hardware.<a href="./src/replicate/resources/hardware.py">retrieve_collections</a>(collection_slug) -> None</code>
 
 # Accounts
 

src/replicate/resources/hardware.py

@@ -39,7 +39,45 @@ def with_streaming_response(self) -> HardwareResourceWithStreamingResponse:
         """
         return HardwareResourceWithStreamingResponse(self)
 
-    def retrieve(
+    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,
+    ) -> HardwareListResponse:
+        """
+        Example cURL request:
+
+        ```console
+        curl -s \\
+          -H "Authorization: Bearer $REPLICATE_API_TOKEN" \\
+          https://api.replicate.com/v1/hardware
+        ```
+
+        The response will be a JSON array of hardware objects:
+
+        ```json
+        [
+          { "name": "CPU", "sku": "cpu" },
+          { "name": "Nvidia T4 GPU", "sku": "gpu-t4" },
+          { "name": "Nvidia A40 GPU", "sku": "gpu-a40-small" },
+          { "name": "Nvidia A40 (Large) GPU", "sku": "gpu-a40-large" }
+        ]
+        ```
+        """
+        return self._get(
+            "/hardware",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=HardwareListResponse,
+        )
+
+    def retrieve_collections(
         self,
         collection_slug: str,
         *,
@@ -91,7 +129,28 @@ def retrieve(
             cast_to=NoneType,
         )
 
-    def list(
+
+class AsyncHardwareResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncHardwareResourceWithRawResponse:
+        """
+        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/zeke/replicate-client-python-prod-for-fun#accessing-raw-response-data-eg-headers
+        """
+        return AsyncHardwareResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncHardwareResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/zeke/replicate-client-python-prod-for-fun#with_streaming_response
+        """
+        return AsyncHardwareResourceWithStreamingResponse(self)
+
+    async def list(
         self,
         *,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -121,36 +180,15 @@ def list(
         ]
         ```
         """
-        return self._get(
+        return await self._get(
             "/hardware",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=HardwareListResponse,
         )
 
-
-class AsyncHardwareResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncHardwareResourceWithRawResponse:
-        """
-        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/zeke/replicate-client-python-prod-for-fun#accessing-raw-response-data-eg-headers
-        """
-        return AsyncHardwareResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncHardwareResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/zeke/replicate-client-python-prod-for-fun#with_streaming_response
-        """
-        return AsyncHardwareResourceWithStreamingResponse(self)
-
-    async def retrieve(
+    async def retrieve_collections(
         self,
         collection_slug: str,
         *,
@@ -202,88 +240,50 @@ async def retrieve(
             cast_to=NoneType,
         )
 
-    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,
-    ) -> HardwareListResponse:
-        """
-        Example cURL request:
-
-        ```console
-        curl -s \\
-          -H "Authorization: Bearer $REPLICATE_API_TOKEN" \\
-          https://api.replicate.com/v1/hardware
-        ```
-
-        The response will be a JSON array of hardware objects:
-
-        ```json
-        [
-          { "name": "CPU", "sku": "cpu" },
-          { "name": "Nvidia T4 GPU", "sku": "gpu-t4" },
-          { "name": "Nvidia A40 GPU", "sku": "gpu-a40-small" },
-          { "name": "Nvidia A40 (Large) GPU", "sku": "gpu-a40-large" }
-        ]
-        ```
-        """
-        return await self._get(
-            "/hardware",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=HardwareListResponse,
-        )
-
 
 class HardwareResourceWithRawResponse:
     def __init__(self, hardware: HardwareResource) -> None:
         self._hardware = hardware
 
-        self.retrieve = to_raw_response_wrapper(
-            hardware.retrieve,
-        )
         self.list = to_raw_response_wrapper(
             hardware.list,
         )
+        self.retrieve_collections = to_raw_response_wrapper(
+            hardware.retrieve_collections,
+        )
 
 
 class AsyncHardwareResourceWithRawResponse:
     def __init__(self, hardware: AsyncHardwareResource) -> None:
         self._hardware = hardware
 
-        self.retrieve = async_to_raw_response_wrapper(
-            hardware.retrieve,
-        )
         self.list = async_to_raw_response_wrapper(
             hardware.list,
         )
+        self.retrieve_collections = async_to_raw_response_wrapper(
+            hardware.retrieve_collections,
+        )
 
 
 class HardwareResourceWithStreamingResponse:
     def __init__(self, hardware: HardwareResource) -> None:
         self._hardware = hardware
 
-        self.retrieve = to_streamed_response_wrapper(
-            hardware.retrieve,
-        )
         self.list = to_streamed_response_wrapper(
             hardware.list,
         )
+        self.retrieve_collections = to_streamed_response_wrapper(
+            hardware.retrieve_collections,
+        )
 
 
 class AsyncHardwareResourceWithStreamingResponse:
     def __init__(self, hardware: AsyncHardwareResource) -> None:
         self._hardware = hardware
 
-        self.retrieve = async_to_streamed_response_wrapper(
-            hardware.retrieve,
-        )
         self.list = async_to_streamed_response_wrapper(
             hardware.list,
         )
+        self.retrieve_collections = async_to_streamed_response_wrapper(
+            hardware.retrieve_collections,
+        )

tests/api_resources/test_hardware.py

@@ -17,48 +17,6 @@
 class TestHardware:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
-    @parametrize
-    def test_method_retrieve(self, client: ReplicateClient) -> None:
-        hardware = client.hardware.retrieve(
-            "collection_slug",
-        )
-        assert hardware is None
-
-    @pytest.mark.skip()
-    @parametrize
-    def test_raw_response_retrieve(self, client: ReplicateClient) -> None:
-        response = client.hardware.with_raw_response.retrieve(
-            "collection_slug",
-        )
-
-        assert response.is_closed is True
-        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        hardware = response.parse()
-        assert hardware is None
-
-    @pytest.mark.skip()
-    @parametrize
-    def test_streaming_response_retrieve(self, client: ReplicateClient) -> None:
-        with client.hardware.with_streaming_response.retrieve(
-            "collection_slug",
-        ) as response:
-            assert not response.is_closed
-            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
-            hardware = response.parse()
-            assert hardware is None
-
-        assert cast(Any, response.is_closed) is True
-
-    @pytest.mark.skip()
-    @parametrize
-    def test_path_params_retrieve(self, client: ReplicateClient) -> None:
-        with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection_slug` but received ''"):
-            client.hardware.with_raw_response.retrieve(
-                "",
-            )
-
     @pytest.mark.skip()
     @parametrize
     def test_method_list(self, client: ReplicateClient) -> None:
@@ -87,52 +45,52 @@ def test_streaming_response_list(self, client: ReplicateClient) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-
-class TestAsyncHardware:
-    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
-
     @pytest.mark.skip()
     @parametrize
-    async def test_method_retrieve(self, async_client: AsyncReplicateClient) -> None:
-        hardware = await async_client.hardware.retrieve(
+    def test_method_retrieve_collections(self, client: ReplicateClient) -> None:
+        hardware = client.hardware.retrieve_collections(
             "collection_slug",
         )
         assert hardware is None
 
     @pytest.mark.skip()
     @parametrize
-    async def test_raw_response_retrieve(self, async_client: AsyncReplicateClient) -> None:
-        response = await async_client.hardware.with_raw_response.retrieve(
+    def test_raw_response_retrieve_collections(self, client: ReplicateClient) -> None:
+        response = client.hardware.with_raw_response.retrieve_collections(
             "collection_slug",
         )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-        hardware = await response.parse()
+        hardware = response.parse()
         assert hardware is None
 
     @pytest.mark.skip()
     @parametrize
-    async def test_streaming_response_retrieve(self, async_client: AsyncReplicateClient) -> None:
-        async with async_client.hardware.with_streaming_response.retrieve(
+    def test_streaming_response_retrieve_collections(self, client: ReplicateClient) -> None:
+        with client.hardware.with_streaming_response.retrieve_collections(
             "collection_slug",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
-            hardware = await response.parse()
+            hardware = response.parse()
             assert hardware is None
 
         assert cast(Any, response.is_closed) is True
 
     @pytest.mark.skip()
     @parametrize
-    async def test_path_params_retrieve(self, async_client: AsyncReplicateClient) -> None:
+    def test_path_params_retrieve_collections(self, client: ReplicateClient) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection_slug` but received ''"):
-            await async_client.hardware.with_raw_response.retrieve(
+            client.hardware.with_raw_response.retrieve_collections(
                 "",
             )
 
+
+class TestAsyncHardware:
+    parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
+
     @pytest.mark.skip()
     @parametrize
     async def test_method_list(self, async_client: AsyncReplicateClient) -> None:
@@ -160,3 +118,45 @@ async def test_streaming_response_list(self, async_client: AsyncReplicateClient)
             assert_matches_type(HardwareListResponse, hardware, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip()
+    @parametrize
+    async def test_method_retrieve_collections(self, async_client: AsyncReplicateClient) -> None:
+        hardware = await async_client.hardware.retrieve_collections(
+            "collection_slug",
+        )
+        assert hardware is None
+
+    @pytest.mark.skip()
+    @parametrize
+    async def test_raw_response_retrieve_collections(self, async_client: AsyncReplicateClient) -> None:
+        response = await async_client.hardware.with_raw_response.retrieve_collections(
+            "collection_slug",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        hardware = await response.parse()
+        assert hardware is None
+
+    @pytest.mark.skip()
+    @parametrize
+    async def test_streaming_response_retrieve_collections(self, async_client: AsyncReplicateClient) -> None:
+        async with async_client.hardware.with_streaming_response.retrieve_collections(
+            "collection_slug",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            hardware = await response.parse()
+            assert hardware is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip()
+    @parametrize
+    async def test_path_params_retrieve_collections(self, async_client: AsyncReplicateClient) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection_slug` but received ''"):
+            await async_client.hardware.with_raw_response.retrieve_collections(
+                "",
+            )