isaacus 0.9.1__py3-none-any.whl → 0.10.1__py3-none-any.whl

isaacus/_base_client.py

@@ -9,6 +9,7 @@ import asyncio
 import inspect
 import logging
 import platform
+import warnings
 import email.utils
 from types import TracebackType
 from random import random
@@ -51,9 +52,11 @@ from ._types import (
     ResponseT,
     AnyMapping,
     PostParser,
+    BinaryTypes,
     RequestFiles,
     HttpxSendArgs,
     RequestOptions,
+    AsyncBinaryTypes,
     HttpxRequestFiles,
     ModelBuilderProtocol,
     not_given,
@@ -83,6 +86,7 @@ from ._exceptions import (
     APIConnectionError,
     APIResponseValidationError,
 )
+from ._utils._json import openapi_dumps
 
 log: logging.Logger = logging.getLogger(__name__)
 
@@ -477,8 +481,19 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         retries_taken: int = 0,
     ) -> httpx.Request:
         if log.isEnabledFor(logging.DEBUG):
-            log.debug("Request options: %s", model_dump(options, exclude_unset=True))
-
+            log.debug(
+                "Request options: %s",
+                model_dump(
+                    options,
+                    exclude_unset=True,
+                    # Pydantic v1 can't dump every type we support in content, so we exclude it for now.
+                    exclude={
+                        "content",
+                    }
+                    if PYDANTIC_V1
+                    else {},
+                ),
+            )
         kwargs: dict[str, Any] = {}
 
         json_data = options.json_data
@@ -532,10 +547,18 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         is_body_allowed = options.method.lower() != "get"
 
         if is_body_allowed:
-            if isinstance(json_data, bytes):
+            if options.content is not None and json_data is not None:
+                raise TypeError("Passing both `content` and `json_data` is not supported")
+            if options.content is not None and files is not None:
+                raise TypeError("Passing both `content` and `files` is not supported")
+            if options.content is not None:
+                kwargs["content"] = options.content
+            elif isinstance(json_data, bytes):
                 kwargs["content"] = json_data
-            else:
-                kwargs["json"] = json_data if is_given(json_data) else None
+            elif not files:
+                # Don't set content when JSON is sent as multipart/form-data,
+                # since httpx's content param overrides other body arguments
+                kwargs["content"] = openapi_dumps(json_data) if is_given(json_data) and json_data is not None else None
             kwargs["files"] = files
         else:
             headers.pop("Content-Type", None)
@@ -1194,6 +1217,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: Literal[False] = False,
@@ -1206,6 +1230,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: Literal[True],
@@ -1219,6 +1244,7 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: bool,
@@ -1231,13 +1257,25 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
         files: RequestFiles | None = None,
         stream: bool = False,
         stream_cls: type[_StreamT] | None = None,
     ) -> ResponseT | _StreamT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="post", url=path, json_data=body, files=to_httpx_files(files), **options
+            method="post", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
         )
         return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))
 
@@ -1247,9 +1285,24 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
+        files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(
+            method="patch", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
+        )
         return self.request(cast_to, opts)
 
     def put(
@@ -1258,11 +1311,23 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="put", url=path, json_data=body, files=to_httpx_files(files), **options
+            method="put", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
         )
         return self.request(cast_to, opts)
 
@@ -1272,9 +1337,19 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: BinaryTypes | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options)
         return self.request(cast_to, opts)
 
     def get_api_list(
@@ -1714,6 +1789,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: Literal[False] = False,
@@ -1726,6 +1802,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: Literal[True],
@@ -1739,6 +1816,7 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: bool,
@@ -1751,13 +1829,25 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
         stream: bool = False,
         stream_cls: type[_AsyncStreamT] | None = None,
     ) -> ResponseT | _AsyncStreamT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="post", url=path, json_data=body, files=await async_to_httpx_files(files), **options
+            method="post", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options
         )
         return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)
 
@@ -1767,9 +1857,29 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
+        files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(
+            method="patch",
+            url=path,
+            json_data=body,
+            content=content,
+            files=await async_to_httpx_files(files),
+            **options,
+        )
         return await self.request(cast_to, opts)
 
     async def put(
@@ -1778,11 +1888,23 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         files: RequestFiles | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if files is not None and content is not None:
+            raise TypeError("Passing both `files` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         opts = FinalRequestOptions.construct(
-            method="put", url=path, json_data=body, files=await async_to_httpx_files(files), **options
+            method="put", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options
         )
         return await self.request(cast_to, opts)
 
@@ -1792,9 +1914,19 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         *,
         cast_to: Type[ResponseT],
         body: Body | None = None,
+        content: AsyncBinaryTypes | None = None,
         options: RequestOptions = {},
     ) -> ResponseT:
-        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options)
+        if body is not None and content is not None:
+            raise TypeError("Passing both `body` and `content` is not supported")
+        if isinstance(body, bytes):
+            warnings.warn(
+                "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
+                "Please pass raw bytes via the `content` parameter instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options)
         return await self.request(cast_to, opts)
 
     def get_api_list(

isaacus/_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,8 +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 embeddings, rerankings
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import IsaacusError, APIStatusError
 from ._base_client import (
@@ -29,20 +29,19 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
-from .resources.extractions import extractions
-from .resources.classifications import classifications
+
+if TYPE_CHECKING:
+    from .resources import embeddings, rerankings, enrichments, extractions, classifications
+    from .resources.embeddings import EmbeddingsResource, AsyncEmbeddingsResource
+    from .resources.rerankings import RerankingsResource, AsyncRerankingsResource
+    from .resources.enrichments import EnrichmentsResource, AsyncEnrichmentsResource
+    from .resources.extractions.extractions import ExtractionsResource, AsyncExtractionsResource
+    from .resources.classifications.classifications import ClassificationsResource, AsyncClassificationsResource
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Isaacus", "AsyncIsaacus", "Client", "AsyncClient"]
 
 
 class Isaacus(SyncAPIClient):
-    embeddings: embeddings.EmbeddingsResource
-    classifications: classifications.ClassificationsResource
-    rerankings: rerankings.RerankingsResource
-    extractions: extractions.ExtractionsResource
-    with_raw_response: IsaacusWithRawResponse
-    with_streaming_response: IsaacusWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -97,12 +96,43 @@ class Isaacus(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.embeddings = embeddings.EmbeddingsResource(self)
-        self.classifications = classifications.ClassificationsResource(self)
-        self.rerankings = rerankings.RerankingsResource(self)
-        self.extractions = extractions.ExtractionsResource(self)
-        self.with_raw_response = IsaacusWithRawResponse(self)
-        self.with_streaming_response = IsaacusWithStreamedResponse(self)
+    @cached_property
+    def embeddings(self) -> EmbeddingsResource:
+        from .resources.embeddings import EmbeddingsResource
+
+        return EmbeddingsResource(self)
+
+    @cached_property
+    def classifications(self) -> ClassificationsResource:
+        from .resources.classifications import ClassificationsResource
+
+        return ClassificationsResource(self)
+
+    @cached_property
+    def rerankings(self) -> RerankingsResource:
+        from .resources.rerankings import RerankingsResource
+
+        return RerankingsResource(self)
+
+    @cached_property
+    def extractions(self) -> ExtractionsResource:
+        from .resources.extractions import ExtractionsResource
+
+        return ExtractionsResource(self)
+
+    @cached_property
+    def enrichments(self) -> EnrichmentsResource:
+        from .resources.enrichments import EnrichmentsResource
+
+        return EnrichmentsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> IsaacusWithRawResponse:
+        return IsaacusWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> IsaacusWithStreamedResponse:
+        return IsaacusWithStreamedResponse(self)
 
     @property
     @override
@@ -210,13 +240,6 @@ class Isaacus(SyncAPIClient):
 
 
 class AsyncIsaacus(AsyncAPIClient):
-    embeddings: embeddings.AsyncEmbeddingsResource
-    classifications: classifications.AsyncClassificationsResource
-    rerankings: rerankings.AsyncRerankingsResource
-    extractions: extractions.AsyncExtractionsResource
-    with_raw_response: AsyncIsaacusWithRawResponse
-    with_streaming_response: AsyncIsaacusWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -271,12 +294,43 @@ class AsyncIsaacus(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.embeddings = embeddings.AsyncEmbeddingsResource(self)
-        self.classifications = classifications.AsyncClassificationsResource(self)
-        self.rerankings = rerankings.AsyncRerankingsResource(self)
-        self.extractions = extractions.AsyncExtractionsResource(self)
-        self.with_raw_response = AsyncIsaacusWithRawResponse(self)
-        self.with_streaming_response = AsyncIsaacusWithStreamedResponse(self)
+    @cached_property
+    def embeddings(self) -> AsyncEmbeddingsResource:
+        from .resources.embeddings import AsyncEmbeddingsResource
+
+        return AsyncEmbeddingsResource(self)
+
+    @cached_property
+    def classifications(self) -> AsyncClassificationsResource:
+        from .resources.classifications import AsyncClassificationsResource
+
+        return AsyncClassificationsResource(self)
+
+    @cached_property
+    def rerankings(self) -> AsyncRerankingsResource:
+        from .resources.rerankings import AsyncRerankingsResource
+
+        return AsyncRerankingsResource(self)
+
+    @cached_property
+    def extractions(self) -> AsyncExtractionsResource:
+        from .resources.extractions import AsyncExtractionsResource
+
+        return AsyncExtractionsResource(self)
+
+    @cached_property
+    def enrichments(self) -> AsyncEnrichmentsResource:
+        from .resources.enrichments import AsyncEnrichmentsResource
+
+        return AsyncEnrichmentsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncIsaacusWithRawResponse:
+        return AsyncIsaacusWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncIsaacusWithStreamedResponse:
+        return AsyncIsaacusWithStreamedResponse(self)
 
     @property
     @override
@@ -384,35 +438,151 @@ class AsyncIsaacus(AsyncAPIClient):
 
 
 class IsaacusWithRawResponse:
+    _client: Isaacus
+
     def __init__(self, client: Isaacus) -> None:
-        self.embeddings = embeddings.EmbeddingsResourceWithRawResponse(client.embeddings)
-        self.classifications = classifications.ClassificationsResourceWithRawResponse(client.classifications)
-        self.rerankings = rerankings.RerankingsResourceWithRawResponse(client.rerankings)
-        self.extractions = extractions.ExtractionsResourceWithRawResponse(client.extractions)
+        self._client = client
+
+    @cached_property
+    def embeddings(self) -> embeddings.EmbeddingsResourceWithRawResponse:
+        from .resources.embeddings import EmbeddingsResourceWithRawResponse
+
+        return EmbeddingsResourceWithRawResponse(self._client.embeddings)
+
+    @cached_property
+    def classifications(self) -> classifications.ClassificationsResourceWithRawResponse:
+        from .resources.classifications import ClassificationsResourceWithRawResponse
+
+        return ClassificationsResourceWithRawResponse(self._client.classifications)
+
+    @cached_property
+    def rerankings(self) -> rerankings.RerankingsResourceWithRawResponse:
+        from .resources.rerankings import RerankingsResourceWithRawResponse
+
+        return RerankingsResourceWithRawResponse(self._client.rerankings)
+
+    @cached_property
+    def extractions(self) -> extractions.ExtractionsResourceWithRawResponse:
+        from .resources.extractions import ExtractionsResourceWithRawResponse
+
+        return ExtractionsResourceWithRawResponse(self._client.extractions)
+
+    @cached_property
+    def enrichments(self) -> enrichments.EnrichmentsResourceWithRawResponse:
+        from .resources.enrichments import EnrichmentsResourceWithRawResponse
+
+        return EnrichmentsResourceWithRawResponse(self._client.enrichments)
 
 
 class AsyncIsaacusWithRawResponse:
+    _client: AsyncIsaacus
+
     def __init__(self, client: AsyncIsaacus) -> None:
-        self.embeddings = embeddings.AsyncEmbeddingsResourceWithRawResponse(client.embeddings)
-        self.classifications = classifications.AsyncClassificationsResourceWithRawResponse(client.classifications)
-        self.rerankings = rerankings.AsyncRerankingsResourceWithRawResponse(client.rerankings)
-        self.extractions = extractions.AsyncExtractionsResourceWithRawResponse(client.extractions)
+        self._client = client
+
+    @cached_property
+    def embeddings(self) -> embeddings.AsyncEmbeddingsResourceWithRawResponse:
+        from .resources.embeddings import AsyncEmbeddingsResourceWithRawResponse
+
+        return AsyncEmbeddingsResourceWithRawResponse(self._client.embeddings)
+
+    @cached_property
+    def classifications(self) -> classifications.AsyncClassificationsResourceWithRawResponse:
+        from .resources.classifications import AsyncClassificationsResourceWithRawResponse
+
+        return AsyncClassificationsResourceWithRawResponse(self._client.classifications)
+
+    @cached_property
+    def rerankings(self) -> rerankings.AsyncRerankingsResourceWithRawResponse:
+        from .resources.rerankings import AsyncRerankingsResourceWithRawResponse
+
+        return AsyncRerankingsResourceWithRawResponse(self._client.rerankings)
+
+    @cached_property
+    def extractions(self) -> extractions.AsyncExtractionsResourceWithRawResponse:
+        from .resources.extractions import AsyncExtractionsResourceWithRawResponse
+
+        return AsyncExtractionsResourceWithRawResponse(self._client.extractions)
+
+    @cached_property
+    def enrichments(self) -> enrichments.AsyncEnrichmentsResourceWithRawResponse:
+        from .resources.enrichments import AsyncEnrichmentsResourceWithRawResponse
+
+        return AsyncEnrichmentsResourceWithRawResponse(self._client.enrichments)
 
 
 class IsaacusWithStreamedResponse:
+    _client: Isaacus
+
     def __init__(self, client: Isaacus) -> None:
-        self.embeddings = embeddings.EmbeddingsResourceWithStreamingResponse(client.embeddings)
-        self.classifications = classifications.ClassificationsResourceWithStreamingResponse(client.classifications)
-        self.rerankings = rerankings.RerankingsResourceWithStreamingResponse(client.rerankings)
-        self.extractions = extractions.ExtractionsResourceWithStreamingResponse(client.extractions)
+        self._client = client
+
+    @cached_property
+    def embeddings(self) -> embeddings.EmbeddingsResourceWithStreamingResponse:
+        from .resources.embeddings import EmbeddingsResourceWithStreamingResponse
+
+        return EmbeddingsResourceWithStreamingResponse(self._client.embeddings)
+
+    @cached_property
+    def classifications(self) -> classifications.ClassificationsResourceWithStreamingResponse:
+        from .resources.classifications import ClassificationsResourceWithStreamingResponse
+
+        return ClassificationsResourceWithStreamingResponse(self._client.classifications)
+
+    @cached_property
+    def rerankings(self) -> rerankings.RerankingsResourceWithStreamingResponse:
+        from .resources.rerankings import RerankingsResourceWithStreamingResponse
+
+        return RerankingsResourceWithStreamingResponse(self._client.rerankings)
+
+    @cached_property
+    def extractions(self) -> extractions.ExtractionsResourceWithStreamingResponse:
+        from .resources.extractions import ExtractionsResourceWithStreamingResponse
+
+        return ExtractionsResourceWithStreamingResponse(self._client.extractions)
+
+    @cached_property
+    def enrichments(self) -> enrichments.EnrichmentsResourceWithStreamingResponse:
+        from .resources.enrichments import EnrichmentsResourceWithStreamingResponse
+
+        return EnrichmentsResourceWithStreamingResponse(self._client.enrichments)
 
 
 class AsyncIsaacusWithStreamedResponse:
+    _client: AsyncIsaacus
+
     def __init__(self, client: AsyncIsaacus) -> None:
-        self.embeddings = embeddings.AsyncEmbeddingsResourceWithStreamingResponse(client.embeddings)
-        self.classifications = classifications.AsyncClassificationsResourceWithStreamingResponse(client.classifications)
-        self.rerankings = rerankings.AsyncRerankingsResourceWithStreamingResponse(client.rerankings)
-        self.extractions = extractions.AsyncExtractionsResourceWithStreamingResponse(client.extractions)
+        self._client = client
+
+    @cached_property
+    def embeddings(self) -> embeddings.AsyncEmbeddingsResourceWithStreamingResponse:
+        from .resources.embeddings import AsyncEmbeddingsResourceWithStreamingResponse
+
+        return AsyncEmbeddingsResourceWithStreamingResponse(self._client.embeddings)
+
+    @cached_property
+    def classifications(self) -> classifications.AsyncClassificationsResourceWithStreamingResponse:
+        from .resources.classifications import AsyncClassificationsResourceWithStreamingResponse
+
+        return AsyncClassificationsResourceWithStreamingResponse(self._client.classifications)
+
+    @cached_property
+    def rerankings(self) -> rerankings.AsyncRerankingsResourceWithStreamingResponse:
+        from .resources.rerankings import AsyncRerankingsResourceWithStreamingResponse
+
+        return AsyncRerankingsResourceWithStreamingResponse(self._client.rerankings)
+
+    @cached_property
+    def extractions(self) -> extractions.AsyncExtractionsResourceWithStreamingResponse:
+        from .resources.extractions import AsyncExtractionsResourceWithStreamingResponse
+
+        return AsyncExtractionsResourceWithStreamingResponse(self._client.extractions)
+
+    @cached_property
+    def enrichments(self) -> enrichments.AsyncEnrichmentsResourceWithStreamingResponse:
+        from .resources.enrichments import AsyncEnrichmentsResourceWithStreamingResponse
+
+        return AsyncEnrichmentsResourceWithStreamingResponse(self._client.enrichments)
 
 
 Client = Isaacus

isaacus/_compat.py

@@ -139,6 +139,7 @@ def model_dump(
     exclude_defaults: bool = False,
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
+    by_alias: bool | None = None,
 ) -> dict[str, Any]:
     if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
@@ -148,13 +149,12 @@ def model_dump(
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
             warnings=True if PYDANTIC_V1 else warnings,
+            by_alias=by_alias,
         )
     return cast(
         "dict[str, Any]",
         model.dict(  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-            exclude=exclude,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
+            exclude=exclude, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, by_alias=bool(by_alias)
         ),
     )