feat(api): manual updates (#23)

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 27
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/replicate-mpatankar%2Freplicate-client-b45f922f6a041550870a96f5acec02aa6d8830046fc98b95a275c6486f7586fc.yml
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/replicate%2Freplicate-client-b45f922f6a041550870a96f5acec02aa6d8830046fc98b95a275c6486f7586fc.yml
 openapi_spec_hash: ef7fddfb49b4d9c440b0635d2c86f341
-config_hash: ff75d189c98bb571ce62b1d338862231
+config_hash: ce31624b6bbb996036f4bcc4b9525ed6

src/replicate/__init__.py

@@ -1,5 +1,9 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from __future__ import annotations
+
+from typing_extensions import override
+
 from . import types
 from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes
 from ._utils import file_from_path
@@ -92,3 +96,146 @@
         except (TypeError, AttributeError):
             # Some of our exported symbols are builtins which we can't set attributes for.
             pass
+
+# ------ Module level client ------
+import typing as _t
+
+import httpx as _httpx
+
+from ._base_client import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES
+
+bearer_token: str | None = None
+
+base_url: str | _httpx.URL | None = None
+
+timeout: float | Timeout | None = DEFAULT_TIMEOUT
+
+max_retries: int = DEFAULT_MAX_RETRIES
+
+default_headers: _t.Mapping[str, str] | None = None
+
+default_query: _t.Mapping[str, object] | None = None
+
+http_client: _httpx.Client | None = None
+
+
+class _ModuleClient(ReplicateClient):
+    # Note: we have to use type: ignores here as overriding class members
+    # with properties is technically unsafe but it is fine for our use case
+
+    @property  # type: ignore
+    @override
+    def bearer_token(self) -> str | None:
+        return bearer_token
+
+    @bearer_token.setter  # type: ignore
+    def bearer_token(self, value: str | None) -> None:  # type: ignore
+        global bearer_token
+
+        bearer_token = value
+
+    @property
+    @override
+    def base_url(self) -> _httpx.URL:
+        if base_url is not None:
+            return _httpx.URL(base_url)
+
+        return super().base_url
+
+    @base_url.setter
+    def base_url(self, url: _httpx.URL | str) -> None:
+        super().base_url = url  # type: ignore[misc]
+
+    @property  # type: ignore
+    @override
+    def timeout(self) -> float | Timeout | None:
+        return timeout
+
+    @timeout.setter  # type: ignore
+    def timeout(self, value: float | Timeout | None) -> None:  # type: ignore
+        global timeout
+
+        timeout = value
+
+    @property  # type: ignore
+    @override
+    def max_retries(self) -> int:
+        return max_retries
+
+    @max_retries.setter  # type: ignore
+    def max_retries(self, value: int) -> None:  # type: ignore
+        global max_retries
+
+        max_retries = value
+
+    @property  # type: ignore
+    @override
+    def _custom_headers(self) -> _t.Mapping[str, str] | None:
+        return default_headers
+
+    @_custom_headers.setter  # type: ignore
+    def _custom_headers(self, value: _t.Mapping[str, str] | None) -> None:  # type: ignore
+        global default_headers
+
+        default_headers = value
+
+    @property  # type: ignore
+    @override
+    def _custom_query(self) -> _t.Mapping[str, object] | None:
+        return default_query
+
+    @_custom_query.setter  # type: ignore
+    def _custom_query(self, value: _t.Mapping[str, object] | None) -> None:  # type: ignore
+        global default_query
+
+        default_query = value
+
+    @property  # type: ignore
+    @override
+    def _client(self) -> _httpx.Client:
+        return http_client or super()._client
+
+    @_client.setter  # type: ignore
+    def _client(self, value: _httpx.Client) -> None:  # type: ignore
+        global http_client
+
+        http_client = value
+
+
+_client: ReplicateClient | None = None
+
+
+def _load_client() -> ReplicateClient:  # type: ignore[reportUnusedFunction]
+    global _client
+
+    if _client is None:
+        _client = _ModuleClient(
+            bearer_token=bearer_token,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+        )
+        return _client
+
+    return _client
+
+
+def _reset_client() -> None:  # type: ignore[reportUnusedFunction]
+    global _client
+
+    _client = None
+
+
+from ._module_client import (
+    models as models,
+    accounts as accounts,
+    hardware as hardware,
+    webhooks as webhooks,
+    trainings as trainings,
+    collections as collections,
+    deployments as deployments,
+    predictions as predictions,
+)

src/replicate/_module_client.py

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import override
+
+from . import resources, _load_client
+from ._utils import LazyProxy
+
+
+class ModelsResourceProxy(LazyProxy[resources.ModelsResource]):
+    @override
+    def __load__(self) -> resources.ModelsResource:
+        return _load_client().models
+
+
+class HardwareResourceProxy(LazyProxy[resources.HardwareResource]):
+    @override
+    def __load__(self) -> resources.HardwareResource:
+        return _load_client().hardware
+
+
+class AccountsResourceProxy(LazyProxy[resources.AccountsResource]):
+    @override
+    def __load__(self) -> resources.AccountsResource:
+        return _load_client().accounts
+
+
+class WebhooksResourceProxy(LazyProxy[resources.WebhooksResource]):
+    @override
+    def __load__(self) -> resources.WebhooksResource:
+        return _load_client().webhooks
+
+
+class TrainingsResourceProxy(LazyProxy[resources.TrainingsResource]):
+    @override
+    def __load__(self) -> resources.TrainingsResource:
+        return _load_client().trainings
+
+
+class CollectionsResourceProxy(LazyProxy[resources.CollectionsResource]):
+    @override
+    def __load__(self) -> resources.CollectionsResource:
+        return _load_client().collections
+
+
+class DeploymentsResourceProxy(LazyProxy[resources.DeploymentsResource]):
+    @override
+    def __load__(self) -> resources.DeploymentsResource:
+        return _load_client().deployments
+
+
+class PredictionsResourceProxy(LazyProxy[resources.PredictionsResource]):
+    @override
+    def __load__(self) -> resources.PredictionsResource:
+        return _load_client().predictions
+
+
+models: resources.ModelsResource = ModelsResourceProxy().__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__()
+deployments: resources.DeploymentsResource = DeploymentsResourceProxy().__as_proxied__()
+predictions: resources.PredictionsResource = PredictionsResourceProxy().__as_proxied__()

tests/test_module_client.py

@@ -0,0 +1,87 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+import pytest
+from httpx import URL
+
+import replicate
+from replicate import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES
+
+
+def reset_state() -> None:
+    replicate._reset_client()
+    replicate.bearer_token = None or "My Bearer Token"
+    replicate.base_url = None
+    replicate.timeout = DEFAULT_TIMEOUT
+    replicate.max_retries = DEFAULT_MAX_RETRIES
+    replicate.default_headers = None
+    replicate.default_query = None
+    replicate.http_client = None
+
+
+@pytest.fixture(autouse=True)
+def reset_state_fixture() -> None:
+    reset_state()
+
+
+def test_base_url_option() -> None:
+    assert replicate.base_url is None
+    assert replicate.collections._client.base_url == URL("https://api.replicate.com/v1/")
+
+    replicate.base_url = "http://foo.com"
+
+    assert replicate.base_url == URL("http://foo.com")
+    assert replicate.collections._client.base_url == URL("http://foo.com")
+
+
+def test_timeout_option() -> None:
+    assert replicate.timeout == replicate.DEFAULT_TIMEOUT
+    assert replicate.collections._client.timeout == replicate.DEFAULT_TIMEOUT
+
+    replicate.timeout = 3
+
+    assert replicate.timeout == 3
+    assert replicate.collections._client.timeout == 3
+
+
+def test_max_retries_option() -> None:
+    assert replicate.max_retries == replicate.DEFAULT_MAX_RETRIES
+    assert replicate.collections._client.max_retries == replicate.DEFAULT_MAX_RETRIES
+
+    replicate.max_retries = 1
+
+    assert replicate.max_retries == 1
+    assert replicate.collections._client.max_retries == 1
+
+
+def test_default_headers_option() -> None:
+    assert replicate.default_headers == None
+
+    replicate.default_headers = {"Foo": "Bar"}
+
+    assert replicate.default_headers["Foo"] == "Bar"
+    assert replicate.collections._client.default_headers["Foo"] == "Bar"
+
+
+def test_default_query_option() -> None:
+    assert replicate.default_query is None
+    assert replicate.collections._client._custom_query == {}
+
+    replicate.default_query = {"Foo": {"nested": 1}}
+
+    assert replicate.default_query["Foo"] == {"nested": 1}
+    assert replicate.collections._client._custom_query["Foo"] == {"nested": 1}
+
+
+def test_http_client_option() -> None:
+    assert openai.http_client is None
+
+    original_http_client = openai.completions._client._client
+    assert original_http_client is not None
+
+    new_client = httpx.Client()
+    openai.http_client = new_client
+
+    assert openai.completions._client._client is new_client