scale-gp-beta 0.1.0a38__py3-none-any.whl → 0.1.0a40__py3-none-any.whl

scale_gp_beta/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, Mapping, cast
+from typing import TYPE_CHECKING, Any, Dict, Mapping, cast
 from typing_extensions import Self, Literal, override
 
 import httpx
@@ -20,21 +20,8 @@ from ._types import (
     not_given,
 )
 from ._utils import is_given, get_async_library
+from ._compat import cached_property
 from ._version import __version__
-from .resources import (
-    spans,
-    models,
-    datasets,
-    inference,
-    questions,
-    responses,
-    completions,
-    credentials,
-    evaluations,
-    dataset_items,
-    evaluation_items,
-    span_assessments,
-)
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SGPClientError
 from ._base_client import (
@@ -42,8 +29,38 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.chat import chat
-from .resources.files import files
+
+if TYPE_CHECKING:
+    from .resources import (
+        chat,
+        files,
+        spans,
+        models,
+        datasets,
+        inference,
+        questions,
+        responses,
+        completions,
+        credentials,
+        evaluations,
+        dataset_items,
+        evaluation_items,
+        span_assessments,
+    )
+    from .resources.spans import SpansResource, AsyncSpansResource
+    from .resources.models import ModelsResource, AsyncModelsResource
+    from .resources.datasets import DatasetsResource, AsyncDatasetsResource
+    from .resources.chat.chat import ChatResource, AsyncChatResource
+    from .resources.inference import InferenceResource, AsyncInferenceResource
+    from .resources.questions import QuestionsResource, AsyncQuestionsResource
+    from .resources.responses import ResponsesResource, AsyncResponsesResource
+    from .resources.completions import CompletionsResource, AsyncCompletionsResource
+    from .resources.credentials import CredentialsResource, AsyncCredentialsResource
+    from .resources.evaluations import EvaluationsResource, AsyncEvaluationsResource
+    from .resources.files.files import FilesResource, AsyncFilesResource
+    from .resources.dataset_items import DatasetItemsResource, AsyncDatasetItemsResource
+    from .resources.evaluation_items import EvaluationItemsResource, AsyncEvaluationItemsResource
+    from .resources.span_assessments import SpanAssessmentsResource, AsyncSpanAssessmentsResource
 
 __all__ = [
     "ENVIRONMENTS",
@@ -64,23 +81,6 @@ ENVIRONMENTS: Dict[str, str] = {
 
 
 class SGPClient(SyncAPIClient):
-    responses: responses.ResponsesResource
-    completions: completions.CompletionsResource
-    chat: chat.ChatResource
-    inference: inference.InferenceResource
-    questions: questions.QuestionsResource
-    files: files.FilesResource
-    models: models.ModelsResource
-    datasets: datasets.DatasetsResource
-    dataset_items: dataset_items.DatasetItemsResource
-    evaluations: evaluations.EvaluationsResource
-    evaluation_items: evaluation_items.EvaluationItemsResource
-    spans: spans.SpansResource
-    span_assessments: span_assessments.SpanAssessmentsResource
-    credentials: credentials.CredentialsResource
-    with_raw_response: SGPClientWithRawResponse
-    with_streaming_response: SGPClientWithStreamedResponse
-
     # client options
     api_key: str
     account_id: str
@@ -171,22 +171,97 @@ class SGPClient(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.responses = responses.ResponsesResource(self)
-        self.completions = completions.CompletionsResource(self)
-        self.chat = chat.ChatResource(self)
-        self.inference = inference.InferenceResource(self)
-        self.questions = questions.QuestionsResource(self)
-        self.files = files.FilesResource(self)
-        self.models = models.ModelsResource(self)
-        self.datasets = datasets.DatasetsResource(self)
-        self.dataset_items = dataset_items.DatasetItemsResource(self)
-        self.evaluations = evaluations.EvaluationsResource(self)
-        self.evaluation_items = evaluation_items.EvaluationItemsResource(self)
-        self.spans = spans.SpansResource(self)
-        self.span_assessments = span_assessments.SpanAssessmentsResource(self)
-        self.credentials = credentials.CredentialsResource(self)
-        self.with_raw_response = SGPClientWithRawResponse(self)
-        self.with_streaming_response = SGPClientWithStreamedResponse(self)
+    @cached_property
+    def responses(self) -> ResponsesResource:
+        from .resources.responses import ResponsesResource
+
+        return ResponsesResource(self)
+
+    @cached_property
+    def completions(self) -> CompletionsResource:
+        from .resources.completions import CompletionsResource
+
+        return CompletionsResource(self)
+
+    @cached_property
+    def chat(self) -> ChatResource:
+        from .resources.chat import ChatResource
+
+        return ChatResource(self)
+
+    @cached_property
+    def inference(self) -> InferenceResource:
+        from .resources.inference import InferenceResource
+
+        return InferenceResource(self)
+
+    @cached_property
+    def questions(self) -> QuestionsResource:
+        from .resources.questions import QuestionsResource
+
+        return QuestionsResource(self)
+
+    @cached_property
+    def files(self) -> FilesResource:
+        from .resources.files import FilesResource
+
+        return FilesResource(self)
+
+    @cached_property
+    def models(self) -> ModelsResource:
+        from .resources.models import ModelsResource
+
+        return ModelsResource(self)
+
+    @cached_property
+    def datasets(self) -> DatasetsResource:
+        from .resources.datasets import DatasetsResource
+
+        return DatasetsResource(self)
+
+    @cached_property
+    def dataset_items(self) -> DatasetItemsResource:
+        from .resources.dataset_items import DatasetItemsResource
+
+        return DatasetItemsResource(self)
+
+    @cached_property
+    def evaluations(self) -> EvaluationsResource:
+        from .resources.evaluations import EvaluationsResource
+
+        return EvaluationsResource(self)
+
+    @cached_property
+    def evaluation_items(self) -> EvaluationItemsResource:
+        from .resources.evaluation_items import EvaluationItemsResource
+
+        return EvaluationItemsResource(self)
+
+    @cached_property
+    def spans(self) -> SpansResource:
+        from .resources.spans import SpansResource
+
+        return SpansResource(self)
+
+    @cached_property
+    def span_assessments(self) -> SpanAssessmentsResource:
+        from .resources.span_assessments import SpanAssessmentsResource
+
+        return SpanAssessmentsResource(self)
+
+    @cached_property
+    def credentials(self) -> CredentialsResource:
+        from .resources.credentials import CredentialsResource
+
+        return CredentialsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> SGPClientWithRawResponse:
+        return SGPClientWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SGPClientWithStreamedResponse:
+        return SGPClientWithStreamedResponse(self)
 
     @property
     @override
@@ -299,23 +374,6 @@ class SGPClient(SyncAPIClient):
 
 
 class AsyncSGPClient(AsyncAPIClient):
-    responses: responses.AsyncResponsesResource
-    completions: completions.AsyncCompletionsResource
-    chat: chat.AsyncChatResource
-    inference: inference.AsyncInferenceResource
-    questions: questions.AsyncQuestionsResource
-    files: files.AsyncFilesResource
-    models: models.AsyncModelsResource
-    datasets: datasets.AsyncDatasetsResource
-    dataset_items: dataset_items.AsyncDatasetItemsResource
-    evaluations: evaluations.AsyncEvaluationsResource
-    evaluation_items: evaluation_items.AsyncEvaluationItemsResource
-    spans: spans.AsyncSpansResource
-    span_assessments: span_assessments.AsyncSpanAssessmentsResource
-    credentials: credentials.AsyncCredentialsResource
-    with_raw_response: AsyncSGPClientWithRawResponse
-    with_streaming_response: AsyncSGPClientWithStreamedResponse
-
     # client options
     api_key: str
     account_id: str
@@ -406,22 +464,97 @@ class AsyncSGPClient(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.responses = responses.AsyncResponsesResource(self)
-        self.completions = completions.AsyncCompletionsResource(self)
-        self.chat = chat.AsyncChatResource(self)
-        self.inference = inference.AsyncInferenceResource(self)
-        self.questions = questions.AsyncQuestionsResource(self)
-        self.files = files.AsyncFilesResource(self)
-        self.models = models.AsyncModelsResource(self)
-        self.datasets = datasets.AsyncDatasetsResource(self)
-        self.dataset_items = dataset_items.AsyncDatasetItemsResource(self)
-        self.evaluations = evaluations.AsyncEvaluationsResource(self)
-        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResource(self)
-        self.spans = spans.AsyncSpansResource(self)
-        self.span_assessments = span_assessments.AsyncSpanAssessmentsResource(self)
-        self.credentials = credentials.AsyncCredentialsResource(self)
-        self.with_raw_response = AsyncSGPClientWithRawResponse(self)
-        self.with_streaming_response = AsyncSGPClientWithStreamedResponse(self)
+    @cached_property
+    def responses(self) -> AsyncResponsesResource:
+        from .resources.responses import AsyncResponsesResource
+
+        return AsyncResponsesResource(self)
+
+    @cached_property
+    def completions(self) -> AsyncCompletionsResource:
+        from .resources.completions import AsyncCompletionsResource
+
+        return AsyncCompletionsResource(self)
+
+    @cached_property
+    def chat(self) -> AsyncChatResource:
+        from .resources.chat import AsyncChatResource
+
+        return AsyncChatResource(self)
+
+    @cached_property
+    def inference(self) -> AsyncInferenceResource:
+        from .resources.inference import AsyncInferenceResource
+
+        return AsyncInferenceResource(self)
+
+    @cached_property
+    def questions(self) -> AsyncQuestionsResource:
+        from .resources.questions import AsyncQuestionsResource
+
+        return AsyncQuestionsResource(self)
+
+    @cached_property
+    def files(self) -> AsyncFilesResource:
+        from .resources.files import AsyncFilesResource
+
+        return AsyncFilesResource(self)
+
+    @cached_property
+    def models(self) -> AsyncModelsResource:
+        from .resources.models import AsyncModelsResource
+
+        return AsyncModelsResource(self)
+
+    @cached_property
+    def datasets(self) -> AsyncDatasetsResource:
+        from .resources.datasets import AsyncDatasetsResource
+
+        return AsyncDatasetsResource(self)
+
+    @cached_property
+    def dataset_items(self) -> AsyncDatasetItemsResource:
+        from .resources.dataset_items import AsyncDatasetItemsResource
+
+        return AsyncDatasetItemsResource(self)
+
+    @cached_property
+    def evaluations(self) -> AsyncEvaluationsResource:
+        from .resources.evaluations import AsyncEvaluationsResource
+
+        return AsyncEvaluationsResource(self)
+
+    @cached_property
+    def evaluation_items(self) -> AsyncEvaluationItemsResource:
+        from .resources.evaluation_items import AsyncEvaluationItemsResource
+
+        return AsyncEvaluationItemsResource(self)
+
+    @cached_property
+    def spans(self) -> AsyncSpansResource:
+        from .resources.spans import AsyncSpansResource
+
+        return AsyncSpansResource(self)
+
+    @cached_property
+    def span_assessments(self) -> AsyncSpanAssessmentsResource:
+        from .resources.span_assessments import AsyncSpanAssessmentsResource
+
+        return AsyncSpanAssessmentsResource(self)
+
+    @cached_property
+    def credentials(self) -> AsyncCredentialsResource:
+        from .resources.credentials import AsyncCredentialsResource
+
+        return AsyncCredentialsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSGPClientWithRawResponse:
+        return AsyncSGPClientWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSGPClientWithStreamedResponse:
+        return AsyncSGPClientWithStreamedResponse(self)
 
     @property
     @override
@@ -534,79 +667,367 @@ class AsyncSGPClient(AsyncAPIClient):
 
 
 class SGPClientWithRawResponse:
+    _client: SGPClient
+
     def __init__(self, client: SGPClient) -> None:
-        self.responses = responses.ResponsesResourceWithRawResponse(client.responses)
-        self.completions = completions.CompletionsResourceWithRawResponse(client.completions)
-        self.chat = chat.ChatResourceWithRawResponse(client.chat)
-        self.inference = inference.InferenceResourceWithRawResponse(client.inference)
-        self.questions = questions.QuestionsResourceWithRawResponse(client.questions)
-        self.files = files.FilesResourceWithRawResponse(client.files)
-        self.models = models.ModelsResourceWithRawResponse(client.models)
-        self.datasets = datasets.DatasetsResourceWithRawResponse(client.datasets)
-        self.dataset_items = dataset_items.DatasetItemsResourceWithRawResponse(client.dataset_items)
-        self.evaluations = evaluations.EvaluationsResourceWithRawResponse(client.evaluations)
-        self.evaluation_items = evaluation_items.EvaluationItemsResourceWithRawResponse(client.evaluation_items)
-        self.spans = spans.SpansResourceWithRawResponse(client.spans)
-        self.span_assessments = span_assessments.SpanAssessmentsResourceWithRawResponse(client.span_assessments)
-        self.credentials = credentials.CredentialsResourceWithRawResponse(client.credentials)
+        self._client = client
+
+    @cached_property
+    def responses(self) -> responses.ResponsesResourceWithRawResponse:
+        from .resources.responses import ResponsesResourceWithRawResponse
+
+        return ResponsesResourceWithRawResponse(self._client.responses)
+
+    @cached_property
+    def completions(self) -> completions.CompletionsResourceWithRawResponse:
+        from .resources.completions import CompletionsResourceWithRawResponse
+
+        return CompletionsResourceWithRawResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.ChatResourceWithRawResponse:
+        from .resources.chat import ChatResourceWithRawResponse
+
+        return ChatResourceWithRawResponse(self._client.chat)
+
+    @cached_property
+    def inference(self) -> inference.InferenceResourceWithRawResponse:
+        from .resources.inference import InferenceResourceWithRawResponse
+
+        return InferenceResourceWithRawResponse(self._client.inference)
+
+    @cached_property
+    def questions(self) -> questions.QuestionsResourceWithRawResponse:
+        from .resources.questions import QuestionsResourceWithRawResponse
+
+        return QuestionsResourceWithRawResponse(self._client.questions)
+
+    @cached_property
+    def files(self) -> files.FilesResourceWithRawResponse:
+        from .resources.files import FilesResourceWithRawResponse
+
+        return FilesResourceWithRawResponse(self._client.files)
+
+    @cached_property
+    def models(self) -> models.ModelsResourceWithRawResponse:
+        from .resources.models import ModelsResourceWithRawResponse
+
+        return ModelsResourceWithRawResponse(self._client.models)
+
+    @cached_property
+    def datasets(self) -> datasets.DatasetsResourceWithRawResponse:
+        from .resources.datasets import DatasetsResourceWithRawResponse
+
+        return DatasetsResourceWithRawResponse(self._client.datasets)
+
+    @cached_property
+    def dataset_items(self) -> dataset_items.DatasetItemsResourceWithRawResponse:
+        from .resources.dataset_items import DatasetItemsResourceWithRawResponse
+
+        return DatasetItemsResourceWithRawResponse(self._client.dataset_items)
+
+    @cached_property
+    def evaluations(self) -> evaluations.EvaluationsResourceWithRawResponse:
+        from .resources.evaluations import EvaluationsResourceWithRawResponse
+
+        return EvaluationsResourceWithRawResponse(self._client.evaluations)
+
+    @cached_property
+    def evaluation_items(self) -> evaluation_items.EvaluationItemsResourceWithRawResponse:
+        from .resources.evaluation_items import EvaluationItemsResourceWithRawResponse
+
+        return EvaluationItemsResourceWithRawResponse(self._client.evaluation_items)
+
+    @cached_property
+    def spans(self) -> spans.SpansResourceWithRawResponse:
+        from .resources.spans import SpansResourceWithRawResponse
+
+        return SpansResourceWithRawResponse(self._client.spans)
+
+    @cached_property
+    def span_assessments(self) -> span_assessments.SpanAssessmentsResourceWithRawResponse:
+        from .resources.span_assessments import SpanAssessmentsResourceWithRawResponse
+
+        return SpanAssessmentsResourceWithRawResponse(self._client.span_assessments)
+
+    @cached_property
+    def credentials(self) -> credentials.CredentialsResourceWithRawResponse:
+        from .resources.credentials import CredentialsResourceWithRawResponse
+
+        return CredentialsResourceWithRawResponse(self._client.credentials)
 
 
 class AsyncSGPClientWithRawResponse:
+    _client: AsyncSGPClient
+
     def __init__(self, client: AsyncSGPClient) -> None:
-        self.responses = responses.AsyncResponsesResourceWithRawResponse(client.responses)
-        self.completions = completions.AsyncCompletionsResourceWithRawResponse(client.completions)
-        self.chat = chat.AsyncChatResourceWithRawResponse(client.chat)
-        self.inference = inference.AsyncInferenceResourceWithRawResponse(client.inference)
-        self.questions = questions.AsyncQuestionsResourceWithRawResponse(client.questions)
-        self.files = files.AsyncFilesResourceWithRawResponse(client.files)
-        self.models = models.AsyncModelsResourceWithRawResponse(client.models)
-        self.datasets = datasets.AsyncDatasetsResourceWithRawResponse(client.datasets)
-        self.dataset_items = dataset_items.AsyncDatasetItemsResourceWithRawResponse(client.dataset_items)
-        self.evaluations = evaluations.AsyncEvaluationsResourceWithRawResponse(client.evaluations)
-        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResourceWithRawResponse(client.evaluation_items)
-        self.spans = spans.AsyncSpansResourceWithRawResponse(client.spans)
-        self.span_assessments = span_assessments.AsyncSpanAssessmentsResourceWithRawResponse(client.span_assessments)
-        self.credentials = credentials.AsyncCredentialsResourceWithRawResponse(client.credentials)
+        self._client = client
+
+    @cached_property
+    def responses(self) -> responses.AsyncResponsesResourceWithRawResponse:
+        from .resources.responses import AsyncResponsesResourceWithRawResponse
+
+        return AsyncResponsesResourceWithRawResponse(self._client.responses)
+
+    @cached_property
+    def completions(self) -> completions.AsyncCompletionsResourceWithRawResponse:
+        from .resources.completions import AsyncCompletionsResourceWithRawResponse
+
+        return AsyncCompletionsResourceWithRawResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.AsyncChatResourceWithRawResponse:
+        from .resources.chat import AsyncChatResourceWithRawResponse
+
+        return AsyncChatResourceWithRawResponse(self._client.chat)
+
+    @cached_property
+    def inference(self) -> inference.AsyncInferenceResourceWithRawResponse:
+        from .resources.inference import AsyncInferenceResourceWithRawResponse
+
+        return AsyncInferenceResourceWithRawResponse(self._client.inference)
+
+    @cached_property
+    def questions(self) -> questions.AsyncQuestionsResourceWithRawResponse:
+        from .resources.questions import AsyncQuestionsResourceWithRawResponse
+
+        return AsyncQuestionsResourceWithRawResponse(self._client.questions)
+
+    @cached_property
+    def files(self) -> files.AsyncFilesResourceWithRawResponse:
+        from .resources.files import AsyncFilesResourceWithRawResponse
+
+        return AsyncFilesResourceWithRawResponse(self._client.files)
+
+    @cached_property
+    def models(self) -> models.AsyncModelsResourceWithRawResponse:
+        from .resources.models import AsyncModelsResourceWithRawResponse
+
+        return AsyncModelsResourceWithRawResponse(self._client.models)
+
+    @cached_property
+    def datasets(self) -> datasets.AsyncDatasetsResourceWithRawResponse:
+        from .resources.datasets import AsyncDatasetsResourceWithRawResponse
+
+        return AsyncDatasetsResourceWithRawResponse(self._client.datasets)
+
+    @cached_property
+    def dataset_items(self) -> dataset_items.AsyncDatasetItemsResourceWithRawResponse:
+        from .resources.dataset_items import AsyncDatasetItemsResourceWithRawResponse
+
+        return AsyncDatasetItemsResourceWithRawResponse(self._client.dataset_items)
+
+    @cached_property
+    def evaluations(self) -> evaluations.AsyncEvaluationsResourceWithRawResponse:
+        from .resources.evaluations import AsyncEvaluationsResourceWithRawResponse
+
+        return AsyncEvaluationsResourceWithRawResponse(self._client.evaluations)
+
+    @cached_property
+    def evaluation_items(self) -> evaluation_items.AsyncEvaluationItemsResourceWithRawResponse:
+        from .resources.evaluation_items import AsyncEvaluationItemsResourceWithRawResponse
+
+        return AsyncEvaluationItemsResourceWithRawResponse(self._client.evaluation_items)
+
+    @cached_property
+    def spans(self) -> spans.AsyncSpansResourceWithRawResponse:
+        from .resources.spans import AsyncSpansResourceWithRawResponse
+
+        return AsyncSpansResourceWithRawResponse(self._client.spans)
+
+    @cached_property
+    def span_assessments(self) -> span_assessments.AsyncSpanAssessmentsResourceWithRawResponse:
+        from .resources.span_assessments import AsyncSpanAssessmentsResourceWithRawResponse
+
+        return AsyncSpanAssessmentsResourceWithRawResponse(self._client.span_assessments)
+
+    @cached_property
+    def credentials(self) -> credentials.AsyncCredentialsResourceWithRawResponse:
+        from .resources.credentials import AsyncCredentialsResourceWithRawResponse
+
+        return AsyncCredentialsResourceWithRawResponse(self._client.credentials)
 
 
 class SGPClientWithStreamedResponse:
+    _client: SGPClient
+
     def __init__(self, client: SGPClient) -> None:
-        self.responses = responses.ResponsesResourceWithStreamingResponse(client.responses)
-        self.completions = completions.CompletionsResourceWithStreamingResponse(client.completions)
-        self.chat = chat.ChatResourceWithStreamingResponse(client.chat)
-        self.inference = inference.InferenceResourceWithStreamingResponse(client.inference)
-        self.questions = questions.QuestionsResourceWithStreamingResponse(client.questions)
-        self.files = files.FilesResourceWithStreamingResponse(client.files)
-        self.models = models.ModelsResourceWithStreamingResponse(client.models)
-        self.datasets = datasets.DatasetsResourceWithStreamingResponse(client.datasets)
-        self.dataset_items = dataset_items.DatasetItemsResourceWithStreamingResponse(client.dataset_items)
-        self.evaluations = evaluations.EvaluationsResourceWithStreamingResponse(client.evaluations)
-        self.evaluation_items = evaluation_items.EvaluationItemsResourceWithStreamingResponse(client.evaluation_items)
-        self.spans = spans.SpansResourceWithStreamingResponse(client.spans)
-        self.span_assessments = span_assessments.SpanAssessmentsResourceWithStreamingResponse(client.span_assessments)
-        self.credentials = credentials.CredentialsResourceWithStreamingResponse(client.credentials)
+        self._client = client
+
+    @cached_property
+    def responses(self) -> responses.ResponsesResourceWithStreamingResponse:
+        from .resources.responses import ResponsesResourceWithStreamingResponse
+
+        return ResponsesResourceWithStreamingResponse(self._client.responses)
+
+    @cached_property
+    def completions(self) -> completions.CompletionsResourceWithStreamingResponse:
+        from .resources.completions import CompletionsResourceWithStreamingResponse
+
+        return CompletionsResourceWithStreamingResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.ChatResourceWithStreamingResponse:
+        from .resources.chat import ChatResourceWithStreamingResponse
+
+        return ChatResourceWithStreamingResponse(self._client.chat)
+
+    @cached_property
+    def inference(self) -> inference.InferenceResourceWithStreamingResponse:
+        from .resources.inference import InferenceResourceWithStreamingResponse
+
+        return InferenceResourceWithStreamingResponse(self._client.inference)
+
+    @cached_property
+    def questions(self) -> questions.QuestionsResourceWithStreamingResponse:
+        from .resources.questions import QuestionsResourceWithStreamingResponse
+
+        return QuestionsResourceWithStreamingResponse(self._client.questions)
+
+    @cached_property
+    def files(self) -> files.FilesResourceWithStreamingResponse:
+        from .resources.files import FilesResourceWithStreamingResponse
+
+        return FilesResourceWithStreamingResponse(self._client.files)
+
+    @cached_property
+    def models(self) -> models.ModelsResourceWithStreamingResponse:
+        from .resources.models import ModelsResourceWithStreamingResponse
+
+        return ModelsResourceWithStreamingResponse(self._client.models)
+
+    @cached_property
+    def datasets(self) -> datasets.DatasetsResourceWithStreamingResponse:
+        from .resources.datasets import DatasetsResourceWithStreamingResponse
+
+        return DatasetsResourceWithStreamingResponse(self._client.datasets)
+
+    @cached_property
+    def dataset_items(self) -> dataset_items.DatasetItemsResourceWithStreamingResponse:
+        from .resources.dataset_items import DatasetItemsResourceWithStreamingResponse
+
+        return DatasetItemsResourceWithStreamingResponse(self._client.dataset_items)
+
+    @cached_property
+    def evaluations(self) -> evaluations.EvaluationsResourceWithStreamingResponse:
+        from .resources.evaluations import EvaluationsResourceWithStreamingResponse
+
+        return EvaluationsResourceWithStreamingResponse(self._client.evaluations)
+
+    @cached_property
+    def evaluation_items(self) -> evaluation_items.EvaluationItemsResourceWithStreamingResponse:
+        from .resources.evaluation_items import EvaluationItemsResourceWithStreamingResponse
+
+        return EvaluationItemsResourceWithStreamingResponse(self._client.evaluation_items)
+
+    @cached_property
+    def spans(self) -> spans.SpansResourceWithStreamingResponse:
+        from .resources.spans import SpansResourceWithStreamingResponse
+
+        return SpansResourceWithStreamingResponse(self._client.spans)
+
+    @cached_property
+    def span_assessments(self) -> span_assessments.SpanAssessmentsResourceWithStreamingResponse:
+        from .resources.span_assessments import SpanAssessmentsResourceWithStreamingResponse
+
+        return SpanAssessmentsResourceWithStreamingResponse(self._client.span_assessments)
+
+    @cached_property
+    def credentials(self) -> credentials.CredentialsResourceWithStreamingResponse:
+        from .resources.credentials import CredentialsResourceWithStreamingResponse
+
+        return CredentialsResourceWithStreamingResponse(self._client.credentials)
 
 
 class AsyncSGPClientWithStreamedResponse:
+    _client: AsyncSGPClient
+
     def __init__(self, client: AsyncSGPClient) -> None:
-        self.responses = responses.AsyncResponsesResourceWithStreamingResponse(client.responses)
-        self.completions = completions.AsyncCompletionsResourceWithStreamingResponse(client.completions)
-        self.chat = chat.AsyncChatResourceWithStreamingResponse(client.chat)
-        self.inference = inference.AsyncInferenceResourceWithStreamingResponse(client.inference)
-        self.questions = questions.AsyncQuestionsResourceWithStreamingResponse(client.questions)
-        self.files = files.AsyncFilesResourceWithStreamingResponse(client.files)
-        self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
-        self.datasets = datasets.AsyncDatasetsResourceWithStreamingResponse(client.datasets)
-        self.dataset_items = dataset_items.AsyncDatasetItemsResourceWithStreamingResponse(client.dataset_items)
-        self.evaluations = evaluations.AsyncEvaluationsResourceWithStreamingResponse(client.evaluations)
-        self.evaluation_items = evaluation_items.AsyncEvaluationItemsResourceWithStreamingResponse(
-            client.evaluation_items
-        )
-        self.spans = spans.AsyncSpansResourceWithStreamingResponse(client.spans)
-        self.span_assessments = span_assessments.AsyncSpanAssessmentsResourceWithStreamingResponse(
-            client.span_assessments
-        )
-        self.credentials = credentials.AsyncCredentialsResourceWithStreamingResponse(client.credentials)
+        self._client = client
+
+    @cached_property
+    def responses(self) -> responses.AsyncResponsesResourceWithStreamingResponse:
+        from .resources.responses import AsyncResponsesResourceWithStreamingResponse
+
+        return AsyncResponsesResourceWithStreamingResponse(self._client.responses)
+
+    @cached_property
+    def completions(self) -> completions.AsyncCompletionsResourceWithStreamingResponse:
+        from .resources.completions import AsyncCompletionsResourceWithStreamingResponse
+
+        return AsyncCompletionsResourceWithStreamingResponse(self._client.completions)
+
+    @cached_property
+    def chat(self) -> chat.AsyncChatResourceWithStreamingResponse:
+        from .resources.chat import AsyncChatResourceWithStreamingResponse
+
+        return AsyncChatResourceWithStreamingResponse(self._client.chat)
+
+    @cached_property
+    def inference(self) -> inference.AsyncInferenceResourceWithStreamingResponse:
+        from .resources.inference import AsyncInferenceResourceWithStreamingResponse
+
+        return AsyncInferenceResourceWithStreamingResponse(self._client.inference)
+
+    @cached_property
+    def questions(self) -> questions.AsyncQuestionsResourceWithStreamingResponse:
+        from .resources.questions import AsyncQuestionsResourceWithStreamingResponse
+
+        return AsyncQuestionsResourceWithStreamingResponse(self._client.questions)
+
+    @cached_property
+    def files(self) -> files.AsyncFilesResourceWithStreamingResponse:
+        from .resources.files import AsyncFilesResourceWithStreamingResponse
+
+        return AsyncFilesResourceWithStreamingResponse(self._client.files)
+
+    @cached_property
+    def models(self) -> models.AsyncModelsResourceWithStreamingResponse:
+        from .resources.models import AsyncModelsResourceWithStreamingResponse
+
+        return AsyncModelsResourceWithStreamingResponse(self._client.models)
+
+    @cached_property
+    def datasets(self) -> datasets.AsyncDatasetsResourceWithStreamingResponse:
+        from .resources.datasets import AsyncDatasetsResourceWithStreamingResponse
+
+        return AsyncDatasetsResourceWithStreamingResponse(self._client.datasets)
+
+    @cached_property
+    def dataset_items(self) -> dataset_items.AsyncDatasetItemsResourceWithStreamingResponse:
+        from .resources.dataset_items import AsyncDatasetItemsResourceWithStreamingResponse
+
+        return AsyncDatasetItemsResourceWithStreamingResponse(self._client.dataset_items)
+
+    @cached_property
+    def evaluations(self) -> evaluations.AsyncEvaluationsResourceWithStreamingResponse:
+        from .resources.evaluations import AsyncEvaluationsResourceWithStreamingResponse
+
+        return AsyncEvaluationsResourceWithStreamingResponse(self._client.evaluations)
+
+    @cached_property
+    def evaluation_items(self) -> evaluation_items.AsyncEvaluationItemsResourceWithStreamingResponse:
+        from .resources.evaluation_items import AsyncEvaluationItemsResourceWithStreamingResponse
+
+        return AsyncEvaluationItemsResourceWithStreamingResponse(self._client.evaluation_items)
+
+    @cached_property
+    def spans(self) -> spans.AsyncSpansResourceWithStreamingResponse:
+        from .resources.spans import AsyncSpansResourceWithStreamingResponse
+
+        return AsyncSpansResourceWithStreamingResponse(self._client.spans)
+
+    @cached_property
+    def span_assessments(self) -> span_assessments.AsyncSpanAssessmentsResourceWithStreamingResponse:
+        from .resources.span_assessments import AsyncSpanAssessmentsResourceWithStreamingResponse
+
+        return AsyncSpanAssessmentsResourceWithStreamingResponse(self._client.span_assessments)
+
+    @cached_property
+    def credentials(self) -> credentials.AsyncCredentialsResourceWithStreamingResponse:
+        from .resources.credentials import AsyncCredentialsResourceWithStreamingResponse
+
+        return AsyncCredentialsResourceWithStreamingResponse(self._client.credentials)
 
 
 Client = SGPClient