fix: update module level client (#2185)

Author: stainless-app[bot]

Diff for: src/openai/__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
@@ -82,3 +86,181 @@
         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
+
+api_key: str | None = None
+
+organization: str | None = None
+
+project: 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(OpenAI):
+    # 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 api_key(self) -> str | None:
+        return api_key
+
+    @api_key.setter  # type: ignore
+    def api_key(self, value: str | None) -> None:  # type: ignore
+        global api_key
+
+        api_key = value
+
+    @property  # type: ignore
+    @override
+    def organization(self) -> str | None:
+        return organization
+
+    @organization.setter  # type: ignore
+    def organization(self, value: str | None) -> None:  # type: ignore
+        global organization
+
+        organization = value
+
+    @property  # type: ignore
+    @override
+    def project(self) -> str | None:
+        return project
+
+    @project.setter  # type: ignore
+    def project(self, value: str | None) -> None:  # type: ignore
+        global project
+
+        project = 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: OpenAI | None = None
+
+
+def _load_client() -> OpenAI:  # type: ignore[reportUnusedFunction]
+    global _client
+
+    if _client is None:
+        _client = _ModuleClient(
+            api_key=api_key,
+            organization=organization,
+            project=project,
+            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 (
+    beta as beta,
+    chat as chat,
+    audio as audio,
+    files as files,
+    client as client,
+    images as images,
+    models as models,
+    batches as batches,
+    uploads as uploads,
+    responses as responses,
+    embeddings as embeddings,
+    completions as completions,
+    fine_tuning as fine_tuning,
+    moderations as moderations,
+    vector_stores as vector_stores,
+)

Diff for: src/openai/_module_client.py

@@ -0,0 +1,113 @@
+# 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 ChatProxy(LazyProxy[resources.Chat]):
+    @override
+    def __load__(self) -> resources.Chat:
+        return _load_client().chat
+
+
+class BetaProxy(LazyProxy[resources.Beta]):
+    @override
+    def __load__(self) -> resources.Beta:
+        return _load_client().beta
+
+
+class FilesProxy(LazyProxy[resources.Files]):
+    @override
+    def __load__(self) -> resources.Files:
+        return _load_client().files
+
+
+class AudioProxy(LazyProxy[resources.Audio]):
+    @override
+    def __load__(self) -> resources.Audio:
+        return _load_client().audio
+
+
+class ImagesProxy(LazyProxy[resources.Images]):
+    @override
+    def __load__(self) -> resources.Images:
+        return _load_client().images
+
+
+class ModelsProxy(LazyProxy[resources.Models]):
+    @override
+    def __load__(self) -> resources.Models:
+        return _load_client().models
+
+
+class ClientProxy(LazyProxy[resources.OpenAI]):
+    @override
+    def __load__(self) -> resources.OpenAI:
+        return _load_client().client
+
+
+class BatchesProxy(LazyProxy[resources.Batches]):
+    @override
+    def __load__(self) -> resources.Batches:
+        return _load_client().batches
+
+
+class UploadsProxy(LazyProxy[resources.Uploads]):
+    @override
+    def __load__(self) -> resources.Uploads:
+        return _load_client().uploads
+
+
+class ResponsesProxy(LazyProxy[resources.Responses]):
+    @override
+    def __load__(self) -> resources.Responses:
+        return _load_client().responses
+
+
+class EmbeddingsProxy(LazyProxy[resources.Embeddings]):
+    @override
+    def __load__(self) -> resources.Embeddings:
+        return _load_client().embeddings
+
+
+class CompletionsProxy(LazyProxy[resources.Completions]):
+    @override
+    def __load__(self) -> resources.Completions:
+        return _load_client().completions
+
+
+class ModerationsProxy(LazyProxy[resources.Moderations]):
+    @override
+    def __load__(self) -> resources.Moderations:
+        return _load_client().moderations
+
+
+class FineTuningProxy(LazyProxy[resources.FineTuning]):
+    @override
+    def __load__(self) -> resources.FineTuning:
+        return _load_client().fine_tuning
+
+
+class VectorStoresProxy(LazyProxy[resources.VectorStores]):
+    @override
+    def __load__(self) -> resources.VectorStores:
+        return _load_client().vector_stores
+
+
+chat: resources.Chat = ChatProxy().__as_proxied__()
+beta: resources.Beta = BetaProxy().__as_proxied__()
+files: resources.Files = FilesProxy().__as_proxied__()
+audio: resources.Audio = AudioProxy().__as_proxied__()
+images: resources.Images = ImagesProxy().__as_proxied__()
+models: resources.Models = ModelsProxy().__as_proxied__()
+client: resources.OpenAI = ClientProxy().__as_proxied__()
+batches: resources.Batches = BatchesProxy().__as_proxied__()
+uploads: resources.Uploads = UploadsProxy().__as_proxied__()
+responses: resources.Responses = ResponsesProxy().__as_proxied__()
+embeddings: resources.Embeddings = EmbeddingsProxy().__as_proxied__()
+completions: resources.Completions = CompletionsProxy().__as_proxied__()
+moderations: resources.Moderations = ModerationsProxy().__as_proxied__()
+fine_tuning: resources.FineTuning = FineTuningProxy().__as_proxied__()
+vector_stores: resources.VectorStores = VectorStoresProxy().__as_proxied__()

Diff for: tests/test_module_client.py

@@ -0,0 +1,89 @@
+# 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 openai
+from openai import DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES
+
+
+def reset_state() -> None:
+    openai._reset_client()
+    openai.api_key = None or "My API Key"
+    openai.organization = None
+    openai.project = None
+    openai.base_url = None
+    openai.timeout = DEFAULT_TIMEOUT
+    openai.max_retries = DEFAULT_MAX_RETRIES
+    openai.default_headers = None
+    openai.default_query = None
+    openai.http_client = None
+
+
+@pytest.fixture(autouse=True)
+def reset_state_fixture() -> None:
+    reset_state()
+
+
+def test_base_url_option() -> None:
+    assert openai.base_url is None
+    assert openai.completions._client.base_url == URL("https://api.openai.com/v1/")
+
+    openai.base_url = "http://foo.com"
+
+    assert openai.base_url == URL("http://foo.com")
+    assert openai.completions._client.base_url == URL("http://foo.com")
+
+
+def test_timeout_option() -> None:
+    assert openai.timeout == openai.DEFAULT_TIMEOUT
+    assert openai.completions._client.timeout == openai.DEFAULT_TIMEOUT
+
+    openai.timeout = 3
+
+    assert openai.timeout == 3
+    assert openai.completions._client.timeout == 3
+
+
+def test_max_retries_option() -> None:
+    assert openai.max_retries == openai.DEFAULT_MAX_RETRIES
+    assert openai.completions._client.max_retries == openai.DEFAULT_MAX_RETRIES
+
+    openai.max_retries = 1
+
+    assert openai.max_retries == 1
+    assert openai.completions._client.max_retries == 1
+
+
+def test_default_headers_option() -> None:
+    assert openai.default_headers == None
+
+    openai.default_headers = {"Foo": "Bar"}
+
+    assert openai.default_headers["Foo"] == "Bar"
+    assert openai.completions._client.default_headers["Foo"] == "Bar"
+
+
+def test_default_query_option() -> None:
+    assert openai.default_query is None
+    assert openai.completions._client._custom_query == {}
+
+    openai.default_query = {"Foo": {"nested": 1}}
+
+    assert openai.default_query["Foo"] == {"nested": 1}
+    assert openai.completions._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