chore: speedup initial import

Author: stainless-app[bot]

src/brainbase/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Mapping
+from typing import TYPE_CHECKING, Any, Mapping
 from typing_extensions import Self, override
 
 import httpx
@@ -20,6 +20,7 @@
     not_given,
 )
 from ._utils import is_given, get_async_library
+from ._compat import cached_property
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, BrainbaseError
@@ -28,7 +29,10 @@
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.workers import workers
+
+if TYPE_CHECKING:
+    from .resources import workers
+    from .resources.workers.workers import WorkersResource, AsyncWorkersResource
 
 __all__ = [
     "Timeout",
@@ -43,10 +47,6 @@
 
 
 class Brainbase(SyncAPIClient):
-    workers: workers.WorkersResource
-    with_raw_response: BrainbaseWithRawResponse
-    with_streaming_response: BrainbaseWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -101,9 +101,19 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.workers = workers.WorkersResource(self)
-        self.with_raw_response = BrainbaseWithRawResponse(self)
-        self.with_streaming_response = BrainbaseWithStreamedResponse(self)
+    @cached_property
+    def workers(self) -> WorkersResource:
+        from .resources.workers import WorkersResource
+
+        return WorkersResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> BrainbaseWithRawResponse:
+        return BrainbaseWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BrainbaseWithStreamedResponse:
+        return BrainbaseWithStreamedResponse(self)
 
     @property
     @override
@@ -211,10 +221,6 @@ def _make_status_error(
 
 
 class AsyncBrainbase(AsyncAPIClient):
-    workers: workers.AsyncWorkersResource
-    with_raw_response: AsyncBrainbaseWithRawResponse
-    with_streaming_response: AsyncBrainbaseWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -269,9 +275,19 @@ def __init__(
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.workers = workers.AsyncWorkersResource(self)
-        self.with_raw_response = AsyncBrainbaseWithRawResponse(self)
-        self.with_streaming_response = AsyncBrainbaseWithStreamedResponse(self)
+    @cached_property
+    def workers(self) -> AsyncWorkersResource:
+        from .resources.workers import AsyncWorkersResource
+
+        return AsyncWorkersResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncBrainbaseWithRawResponse:
+        return AsyncBrainbaseWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBrainbaseWithStreamedResponse:
+        return AsyncBrainbaseWithStreamedResponse(self)
 
     @property
     @override
@@ -379,23 +395,55 @@ def _make_status_error(
 
 
 class BrainbaseWithRawResponse:
+    _client: Brainbase
+
     def __init__(self, client: Brainbase) -> None:
-        self.workers = workers.WorkersResourceWithRawResponse(client.workers)
+        self._client = client
+
+    @cached_property
+    def workers(self) -> workers.WorkersResourceWithRawResponse:
+        from .resources.workers import WorkersResourceWithRawResponse
+
+        return WorkersResourceWithRawResponse(self._client.workers)
 
 
 class AsyncBrainbaseWithRawResponse:
+    _client: AsyncBrainbase
+
     def __init__(self, client: AsyncBrainbase) -> None:
-        self.workers = workers.AsyncWorkersResourceWithRawResponse(client.workers)
+        self._client = client
+
+    @cached_property
+    def workers(self) -> workers.AsyncWorkersResourceWithRawResponse:
+        from .resources.workers import AsyncWorkersResourceWithRawResponse
+
+        return AsyncWorkersResourceWithRawResponse(self._client.workers)
 
 
 class BrainbaseWithStreamedResponse:
+    _client: Brainbase
+
     def __init__(self, client: Brainbase) -> None:
-        self.workers = workers.WorkersResourceWithStreamingResponse(client.workers)
+        self._client = client
+
+    @cached_property
+    def workers(self) -> workers.WorkersResourceWithStreamingResponse:
+        from .resources.workers import WorkersResourceWithStreamingResponse
+
+        return WorkersResourceWithStreamingResponse(self._client.workers)
 
 
 class AsyncBrainbaseWithStreamedResponse:
+    _client: AsyncBrainbase
+
     def __init__(self, client: AsyncBrainbase) -> None:
-        self.workers = workers.AsyncWorkersResourceWithStreamingResponse(client.workers)
+        self._client = client
+
+    @cached_property
+    def workers(self) -> workers.AsyncWorkersResourceWithStreamingResponse:
+        from .resources.workers import AsyncWorkersResourceWithStreamingResponse
+
+        return AsyncWorkersResourceWithStreamingResponse(self._client.workers)
 
 
 Client = Brainbase