fix: correct mapping for account.get

Author: stainless-app[bot]

.stats.yml

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

README.md

@@ -31,8 +31,8 @@ client = ReplicateClient(
     bearer_token=os.environ.get("REPLICATE_API_TOKEN"),  # This is the default and can be omitted
 )
 
-accounts = client.accounts.list()
-print(accounts.type)
+account = client.account.get()
+print(account.type)
 ```
 
 While you can provide a `bearer_token` keyword argument,
@@ -55,8 +55,8 @@ client = AsyncReplicateClient(
 
 
 async def main() -> None:
-    accounts = await client.accounts.list()
-    print(accounts.type)
+    account = await client.account.get()
+    print(account.type)
 
 
 asyncio.run(main())
@@ -152,7 +152,7 @@ from replicate import ReplicateClient
 client = ReplicateClient()
 
 try:
-    client.accounts.list()
+    client.account.get()
 except replicate.APIConnectionError as e:
     print("The server could not be reached")
     print(e.__cause__)  # an underlying Exception, likely raised within httpx.
@@ -195,7 +195,7 @@ client = ReplicateClient(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).accounts.list()
+client.with_options(max_retries=5).account.get()
 ```
 
 ### Timeouts
@@ -218,7 +218,7 @@ client = ReplicateClient(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).accounts.list()
+client.with_options(timeout=5.0).account.get()
 ```
 
 On timeout, an `APITimeoutError` is thrown.
@@ -259,10 +259,10 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from replicate import ReplicateClient
 
 client = ReplicateClient()
-response = client.accounts.with_raw_response.list()
+response = client.account.with_raw_response.get()
 print(response.headers.get('X-My-Header'))
 
-account = response.parse()  # get the object that `accounts.list()` would have returned
+account = response.parse()  # get the object that `account.get()` would have returned
 print(account.type)
 ```
 
@@ -277,7 +277,7 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.accounts.with_streaming_response.list() as response:
+with client.account.with_streaming_response.get() as response:
     print(response.headers.get("X-My-Header"))
 
     for line in response.iter_lines():

api.md

@@ -44,17 +44,17 @@ Methods:
 
 - <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>
 
-# Accounts
+# Account
 
 Types:
 
 ```python
-from replicate.types import AccountListResponse
+from replicate.types import AccountGetResponse
 ```
 
 Methods:
 
-- <code title="get /account">client.accounts.<a href="./src/replicate/resources/accounts.py">list</a>() -> <a href="./src/replicate/types/account_list_response.py">AccountListResponse</a></code>
+- <code title="get /account">client.account.<a href="./src/replicate/resources/account.py">get</a>() -> <a href="./src/replicate/types/account_get_response.py">AccountGetResponse</a></code>
 
 # Models
 

src/replicate/__init__.py

@@ -231,7 +231,7 @@ def _reset_client() -> None:  # type: ignore[reportUnusedFunction]
 
 from ._module_client import (
     models as models,
-    accounts as accounts,
+    account as account,
     hardware as hardware,
     webhooks as webhooks,
     trainings as trainings,

src/replicate/_client.py

@@ -21,7 +21,7 @@
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import accounts, hardware, trainings, collections, predictions
+from .resources import account, hardware, trainings, collections, predictions
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, ReplicateClientError
 from ._base_client import (
@@ -49,7 +49,7 @@ class ReplicateClient(SyncAPIClient):
     collections: collections.CollectionsResource
     deployments: deployments.DeploymentsResource
     hardware: hardware.HardwareResource
-    accounts: accounts.AccountsResource
+    account: account.AccountResource
     models: models.ModelsResource
     predictions: predictions.PredictionsResource
     trainings: trainings.TrainingsResource
@@ -114,7 +114,7 @@ def __init__(
         self.collections = collections.CollectionsResource(self)
         self.deployments = deployments.DeploymentsResource(self)
         self.hardware = hardware.HardwareResource(self)
-        self.accounts = accounts.AccountsResource(self)
+        self.account = account.AccountResource(self)
         self.models = models.ModelsResource(self)
         self.predictions = predictions.PredictionsResource(self)
         self.trainings = trainings.TrainingsResource(self)
@@ -231,7 +231,7 @@ class AsyncReplicateClient(AsyncAPIClient):
     collections: collections.AsyncCollectionsResource
     deployments: deployments.AsyncDeploymentsResource
     hardware: hardware.AsyncHardwareResource
-    accounts: accounts.AsyncAccountsResource
+    account: account.AsyncAccountResource
     models: models.AsyncModelsResource
     predictions: predictions.AsyncPredictionsResource
     trainings: trainings.AsyncTrainingsResource
@@ -296,7 +296,7 @@ def __init__(
         self.collections = collections.AsyncCollectionsResource(self)
         self.deployments = deployments.AsyncDeploymentsResource(self)
         self.hardware = hardware.AsyncHardwareResource(self)
-        self.accounts = accounts.AsyncAccountsResource(self)
+        self.account = account.AsyncAccountResource(self)
         self.models = models.AsyncModelsResource(self)
         self.predictions = predictions.AsyncPredictionsResource(self)
         self.trainings = trainings.AsyncTrainingsResource(self)
@@ -414,7 +414,7 @@ def __init__(self, client: ReplicateClient) -> None:
         self.collections = collections.CollectionsResourceWithRawResponse(client.collections)
         self.deployments = deployments.DeploymentsResourceWithRawResponse(client.deployments)
         self.hardware = hardware.HardwareResourceWithRawResponse(client.hardware)
-        self.accounts = accounts.AccountsResourceWithRawResponse(client.accounts)
+        self.account = account.AccountResourceWithRawResponse(client.account)
         self.models = models.ModelsResourceWithRawResponse(client.models)
         self.predictions = predictions.PredictionsResourceWithRawResponse(client.predictions)
         self.trainings = trainings.TrainingsResourceWithRawResponse(client.trainings)
@@ -426,7 +426,7 @@ def __init__(self, client: AsyncReplicateClient) -> None:
         self.collections = collections.AsyncCollectionsResourceWithRawResponse(client.collections)
         self.deployments = deployments.AsyncDeploymentsResourceWithRawResponse(client.deployments)
         self.hardware = hardware.AsyncHardwareResourceWithRawResponse(client.hardware)
-        self.accounts = accounts.AsyncAccountsResourceWithRawResponse(client.accounts)
+        self.account = account.AsyncAccountResourceWithRawResponse(client.account)
         self.models = models.AsyncModelsResourceWithRawResponse(client.models)
         self.predictions = predictions.AsyncPredictionsResourceWithRawResponse(client.predictions)
         self.trainings = trainings.AsyncTrainingsResourceWithRawResponse(client.trainings)
@@ -438,7 +438,7 @@ def __init__(self, client: ReplicateClient) -> None:
         self.collections = collections.CollectionsResourceWithStreamingResponse(client.collections)
         self.deployments = deployments.DeploymentsResourceWithStreamingResponse(client.deployments)
         self.hardware = hardware.HardwareResourceWithStreamingResponse(client.hardware)
-        self.accounts = accounts.AccountsResourceWithStreamingResponse(client.accounts)
+        self.account = account.AccountResourceWithStreamingResponse(client.account)
         self.models = models.ModelsResourceWithStreamingResponse(client.models)
         self.predictions = predictions.PredictionsResourceWithStreamingResponse(client.predictions)
         self.trainings = trainings.TrainingsResourceWithStreamingResponse(client.trainings)
@@ -450,7 +450,7 @@ def __init__(self, client: AsyncReplicateClient) -> None:
         self.collections = collections.AsyncCollectionsResourceWithStreamingResponse(client.collections)
         self.deployments = deployments.AsyncDeploymentsResourceWithStreamingResponse(client.deployments)
         self.hardware = hardware.AsyncHardwareResourceWithStreamingResponse(client.hardware)
-        self.accounts = accounts.AsyncAccountsResourceWithStreamingResponse(client.accounts)
+        self.account = account.AsyncAccountResourceWithStreamingResponse(client.account)
         self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
         self.predictions = predictions.AsyncPredictionsResourceWithStreamingResponse(client.predictions)
         self.trainings = trainings.AsyncTrainingsResourceWithStreamingResponse(client.trainings)

src/replicate/_module_client.py

@@ -12,16 +12,16 @@ def __load__(self) -> resources.ModelsResource:
         return _load_client().models
 
 
-class HardwareResourceProxy(LazyProxy[resources.HardwareResource]):
+class AccountResourceProxy(LazyProxy[resources.AccountResource]):
     @override
-    def __load__(self) -> resources.HardwareResource:
-        return _load_client().hardware
+    def __load__(self) -> resources.AccountResource:
+        return _load_client().account
 
 
-class AccountsResourceProxy(LazyProxy[resources.AccountsResource]):
+class HardwareResourceProxy(LazyProxy[resources.HardwareResource]):
     @override
-    def __load__(self) -> resources.AccountsResource:
-        return _load_client().accounts
+    def __load__(self) -> resources.HardwareResource:
+        return _load_client().hardware
 
 
 class WebhooksResourceProxy(LazyProxy[resources.WebhooksResource]):
@@ -55,8 +55,8 @@ def __load__(self) -> resources.PredictionsResource:
 
 
 models: resources.ModelsResource = ModelsResourceProxy().__as_proxied__()
+account: resources.AccountResource = AccountResourceProxy().__as_proxied__()
 hardware: resources.HardwareResource = HardwareResourceProxy().__as_proxied__()
-accounts: resources.AccountsResource = AccountsResourceProxy().__as_proxied__()
 webhooks: resources.WebhooksResource = WebhooksResourceProxy().__as_proxied__()
 trainings: resources.TrainingsResource = TrainingsResourceProxy().__as_proxied__()
 collections: resources.CollectionsResource = CollectionsResourceProxy().__as_proxied__()

src/replicate/resources/__init__.py

@@ -8,13 +8,13 @@
     ModelsResourceWithStreamingResponse,
     AsyncModelsResourceWithStreamingResponse,
 )
-from .accounts import (
-    AccountsResource,
-    AsyncAccountsResource,
-    AccountsResourceWithRawResponse,
-    AsyncAccountsResourceWithRawResponse,
-    AccountsResourceWithStreamingResponse,
-    AsyncAccountsResourceWithStreamingResponse,
+from .account import (
+    AccountResource,
+    AsyncAccountResource,
+    AccountResourceWithRawResponse,
+    AsyncAccountResourceWithRawResponse,
+    AccountResourceWithStreamingResponse,
+    AsyncAccountResourceWithStreamingResponse,
 )
 from .hardware import (
     HardwareResource,
@@ -84,12 +84,12 @@
     "AsyncHardwareResourceWithRawResponse",
     "HardwareResourceWithStreamingResponse",
     "AsyncHardwareResourceWithStreamingResponse",
-    "AccountsResource",
-    "AsyncAccountsResource",
-    "AccountsResourceWithRawResponse",
-    "AsyncAccountsResourceWithRawResponse",
-    "AccountsResourceWithStreamingResponse",
-    "AsyncAccountsResourceWithStreamingResponse",
+    "AccountResource",
+    "AsyncAccountResource",
+    "AccountResourceWithRawResponse",
+    "AsyncAccountResourceWithRawResponse",
+    "AccountResourceWithStreamingResponse",
+    "AsyncAccountResourceWithStreamingResponse",
     "ModelsResource",
     "AsyncModelsResource",
     "ModelsResourceWithRawResponse",