casedev 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

casedev/_base_client.py

@@ -86,6 +86,7 @@ from ._exceptions import (
     APIConnectionError,
     APIResponseValidationError,
 )
+from ._utils._json import openapi_dumps
 
 log: logging.Logger = logging.getLogger(__name__)
 
@@ -554,8 +555,10 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
                 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)

casedev/_client.py

@@ -31,14 +31,36 @@ from ._base_client import (
 )
 
 if TYPE_CHECKING:
-    from .resources import llm, ocr, vault, voice, format, search, compute
+    from .resources import (
+        llm,
+        ocr,
+        legal,
+        vault,
+        voice,
+        format,
+        memory,
+        search,
+        compute,
+        database,
+        superdoc,
+        privilege,
+        translate,
+        applications,
+    )
     from .resources.llm.llm import LlmResource, AsyncLlmResource
     from .resources.ocr.ocr import OcrResource, AsyncOcrResource
+    from .resources.legal.legal import LegalResource, AsyncLegalResource
     from .resources.vault.vault import VaultResource, AsyncVaultResource
     from .resources.voice.voice import VoiceResource, AsyncVoiceResource
     from .resources.format.format import FormatResource, AsyncFormatResource
+    from .resources.memory.memory import MemoryResource, AsyncMemoryResource
     from .resources.search.search import SearchResource, AsyncSearchResource
     from .resources.compute.compute import ComputeResource, AsyncComputeResource
+    from .resources.database.database import DatabaseResource, AsyncDatabaseResource
+    from .resources.superdoc.superdoc import SuperdocResource, AsyncSuperdocResource
+    from .resources.privilege.privilege import PrivilegeResource, AsyncPrivilegeResource
+    from .resources.translate.translate import TranslateResource, AsyncTranslateResource
+    from .resources.applications.applications import ApplicationsResource, AsyncApplicationsResource
 
 __all__ = [
     "ENVIRONMENTS",
@@ -137,36 +159,78 @@ class Casedev(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+    @cached_property
+    def applications(self) -> ApplicationsResource:
+        from .resources.applications import ApplicationsResource
+
+        return ApplicationsResource(self)
+
     @cached_property
     def compute(self) -> ComputeResource:
         from .resources.compute import ComputeResource
 
         return ComputeResource(self)
 
+    @cached_property
+    def database(self) -> DatabaseResource:
+        from .resources.database import DatabaseResource
+
+        return DatabaseResource(self)
+
     @cached_property
     def format(self) -> FormatResource:
         from .resources.format import FormatResource
 
         return FormatResource(self)
 
+    @cached_property
+    def legal(self) -> LegalResource:
+        from .resources.legal import LegalResource
+
+        return LegalResource(self)
+
     @cached_property
     def llm(self) -> LlmResource:
         from .resources.llm import LlmResource
 
         return LlmResource(self)
 
+    @cached_property
+    def memory(self) -> MemoryResource:
+        from .resources.memory import MemoryResource
+
+        return MemoryResource(self)
+
     @cached_property
     def ocr(self) -> OcrResource:
         from .resources.ocr import OcrResource
 
         return OcrResource(self)
 
+    @cached_property
+    def privilege(self) -> PrivilegeResource:
+        from .resources.privilege import PrivilegeResource
+
+        return PrivilegeResource(self)
+
     @cached_property
     def search(self) -> SearchResource:
         from .resources.search import SearchResource
 
         return SearchResource(self)
 
+    @cached_property
+    def superdoc(self) -> SuperdocResource:
+        from .resources.superdoc import SuperdocResource
+
+        return SuperdocResource(self)
+
+    @cached_property
+    def translate(self) -> TranslateResource:
+        from .resources.translate import TranslateResource
+
+        return TranslateResource(self)
+
     @cached_property
     def vault(self) -> VaultResource:
         from .resources.vault import VaultResource
@@ -373,36 +437,78 @@ class AsyncCasedev(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+    @cached_property
+    def applications(self) -> AsyncApplicationsResource:
+        from .resources.applications import AsyncApplicationsResource
+
+        return AsyncApplicationsResource(self)
+
     @cached_property
     def compute(self) -> AsyncComputeResource:
         from .resources.compute import AsyncComputeResource
 
         return AsyncComputeResource(self)
 
+    @cached_property
+    def database(self) -> AsyncDatabaseResource:
+        from .resources.database import AsyncDatabaseResource
+
+        return AsyncDatabaseResource(self)
+
     @cached_property
     def format(self) -> AsyncFormatResource:
         from .resources.format import AsyncFormatResource
 
         return AsyncFormatResource(self)
 
+    @cached_property
+    def legal(self) -> AsyncLegalResource:
+        from .resources.legal import AsyncLegalResource
+
+        return AsyncLegalResource(self)
+
     @cached_property
     def llm(self) -> AsyncLlmResource:
         from .resources.llm import AsyncLlmResource
 
         return AsyncLlmResource(self)
 
+    @cached_property
+    def memory(self) -> AsyncMemoryResource:
+        from .resources.memory import AsyncMemoryResource
+
+        return AsyncMemoryResource(self)
+
     @cached_property
     def ocr(self) -> AsyncOcrResource:
         from .resources.ocr import AsyncOcrResource
 
         return AsyncOcrResource(self)
 
+    @cached_property
+    def privilege(self) -> AsyncPrivilegeResource:
+        from .resources.privilege import AsyncPrivilegeResource
+
+        return AsyncPrivilegeResource(self)
+
     @cached_property
     def search(self) -> AsyncSearchResource:
         from .resources.search import AsyncSearchResource
 
         return AsyncSearchResource(self)
 
+    @cached_property
+    def superdoc(self) -> AsyncSuperdocResource:
+        from .resources.superdoc import AsyncSuperdocResource
+
+        return AsyncSuperdocResource(self)
+
+    @cached_property
+    def translate(self) -> AsyncTranslateResource:
+        from .resources.translate import AsyncTranslateResource
+
+        return AsyncTranslateResource(self)
+
     @cached_property
     def vault(self) -> AsyncVaultResource:
         from .resources.vault import AsyncVaultResource
@@ -536,36 +642,78 @@ class CasedevWithRawResponse:
     def __init__(self, client: Casedev) -> None:
         self._client = client
 
+    @cached_property
+    def applications(self) -> applications.ApplicationsResourceWithRawResponse:
+        from .resources.applications import ApplicationsResourceWithRawResponse
+
+        return ApplicationsResourceWithRawResponse(self._client.applications)
+
     @cached_property
     def compute(self) -> compute.ComputeResourceWithRawResponse:
         from .resources.compute import ComputeResourceWithRawResponse
 
         return ComputeResourceWithRawResponse(self._client.compute)
 
+    @cached_property
+    def database(self) -> database.DatabaseResourceWithRawResponse:
+        from .resources.database import DatabaseResourceWithRawResponse
+
+        return DatabaseResourceWithRawResponse(self._client.database)
+
     @cached_property
     def format(self) -> format.FormatResourceWithRawResponse:
         from .resources.format import FormatResourceWithRawResponse
 
         return FormatResourceWithRawResponse(self._client.format)
 
+    @cached_property
+    def legal(self) -> legal.LegalResourceWithRawResponse:
+        from .resources.legal import LegalResourceWithRawResponse
+
+        return LegalResourceWithRawResponse(self._client.legal)
+
     @cached_property
     def llm(self) -> llm.LlmResourceWithRawResponse:
         from .resources.llm import LlmResourceWithRawResponse
 
         return LlmResourceWithRawResponse(self._client.llm)
 
+    @cached_property
+    def memory(self) -> memory.MemoryResourceWithRawResponse:
+        from .resources.memory import MemoryResourceWithRawResponse
+
+        return MemoryResourceWithRawResponse(self._client.memory)
+
     @cached_property
     def ocr(self) -> ocr.OcrResourceWithRawResponse:
         from .resources.ocr import OcrResourceWithRawResponse
 
         return OcrResourceWithRawResponse(self._client.ocr)
 
+    @cached_property
+    def privilege(self) -> privilege.PrivilegeResourceWithRawResponse:
+        from .resources.privilege import PrivilegeResourceWithRawResponse
+
+        return PrivilegeResourceWithRawResponse(self._client.privilege)
+
     @cached_property
     def search(self) -> search.SearchResourceWithRawResponse:
         from .resources.search import SearchResourceWithRawResponse
 
         return SearchResourceWithRawResponse(self._client.search)
 
+    @cached_property
+    def superdoc(self) -> superdoc.SuperdocResourceWithRawResponse:
+        from .resources.superdoc import SuperdocResourceWithRawResponse
+
+        return SuperdocResourceWithRawResponse(self._client.superdoc)
+
+    @cached_property
+    def translate(self) -> translate.TranslateResourceWithRawResponse:
+        from .resources.translate import TranslateResourceWithRawResponse
+
+        return TranslateResourceWithRawResponse(self._client.translate)
+
     @cached_property
     def vault(self) -> vault.VaultResourceWithRawResponse:
         from .resources.vault import VaultResourceWithRawResponse
@@ -585,36 +733,78 @@ class AsyncCasedevWithRawResponse:
     def __init__(self, client: AsyncCasedev) -> None:
         self._client = client
 
+    @cached_property
+    def applications(self) -> applications.AsyncApplicationsResourceWithRawResponse:
+        from .resources.applications import AsyncApplicationsResourceWithRawResponse
+
+        return AsyncApplicationsResourceWithRawResponse(self._client.applications)
+
     @cached_property
     def compute(self) -> compute.AsyncComputeResourceWithRawResponse:
         from .resources.compute import AsyncComputeResourceWithRawResponse
 
         return AsyncComputeResourceWithRawResponse(self._client.compute)
 
+    @cached_property
+    def database(self) -> database.AsyncDatabaseResourceWithRawResponse:
+        from .resources.database import AsyncDatabaseResourceWithRawResponse
+
+        return AsyncDatabaseResourceWithRawResponse(self._client.database)
+
     @cached_property
     def format(self) -> format.AsyncFormatResourceWithRawResponse:
         from .resources.format import AsyncFormatResourceWithRawResponse
 
         return AsyncFormatResourceWithRawResponse(self._client.format)
 
+    @cached_property
+    def legal(self) -> legal.AsyncLegalResourceWithRawResponse:
+        from .resources.legal import AsyncLegalResourceWithRawResponse
+
+        return AsyncLegalResourceWithRawResponse(self._client.legal)
+
     @cached_property
     def llm(self) -> llm.AsyncLlmResourceWithRawResponse:
         from .resources.llm import AsyncLlmResourceWithRawResponse
 
         return AsyncLlmResourceWithRawResponse(self._client.llm)
 
+    @cached_property
+    def memory(self) -> memory.AsyncMemoryResourceWithRawResponse:
+        from .resources.memory import AsyncMemoryResourceWithRawResponse
+
+        return AsyncMemoryResourceWithRawResponse(self._client.memory)
+
     @cached_property
     def ocr(self) -> ocr.AsyncOcrResourceWithRawResponse:
         from .resources.ocr import AsyncOcrResourceWithRawResponse
 
         return AsyncOcrResourceWithRawResponse(self._client.ocr)
 
+    @cached_property
+    def privilege(self) -> privilege.AsyncPrivilegeResourceWithRawResponse:
+        from .resources.privilege import AsyncPrivilegeResourceWithRawResponse
+
+        return AsyncPrivilegeResourceWithRawResponse(self._client.privilege)
+
     @cached_property
     def search(self) -> search.AsyncSearchResourceWithRawResponse:
         from .resources.search import AsyncSearchResourceWithRawResponse
 
         return AsyncSearchResourceWithRawResponse(self._client.search)
 
+    @cached_property
+    def superdoc(self) -> superdoc.AsyncSuperdocResourceWithRawResponse:
+        from .resources.superdoc import AsyncSuperdocResourceWithRawResponse
+
+        return AsyncSuperdocResourceWithRawResponse(self._client.superdoc)
+
+    @cached_property
+    def translate(self) -> translate.AsyncTranslateResourceWithRawResponse:
+        from .resources.translate import AsyncTranslateResourceWithRawResponse
+
+        return AsyncTranslateResourceWithRawResponse(self._client.translate)
+
     @cached_property
     def vault(self) -> vault.AsyncVaultResourceWithRawResponse:
         from .resources.vault import AsyncVaultResourceWithRawResponse
@@ -634,36 +824,78 @@ class CasedevWithStreamedResponse:
     def __init__(self, client: Casedev) -> None:
         self._client = client
 
+    @cached_property
+    def applications(self) -> applications.ApplicationsResourceWithStreamingResponse:
+        from .resources.applications import ApplicationsResourceWithStreamingResponse
+
+        return ApplicationsResourceWithStreamingResponse(self._client.applications)
+
     @cached_property
     def compute(self) -> compute.ComputeResourceWithStreamingResponse:
         from .resources.compute import ComputeResourceWithStreamingResponse
 
         return ComputeResourceWithStreamingResponse(self._client.compute)
 
+    @cached_property
+    def database(self) -> database.DatabaseResourceWithStreamingResponse:
+        from .resources.database import DatabaseResourceWithStreamingResponse
+
+        return DatabaseResourceWithStreamingResponse(self._client.database)
+
     @cached_property
     def format(self) -> format.FormatResourceWithStreamingResponse:
         from .resources.format import FormatResourceWithStreamingResponse
 
         return FormatResourceWithStreamingResponse(self._client.format)
 
+    @cached_property
+    def legal(self) -> legal.LegalResourceWithStreamingResponse:
+        from .resources.legal import LegalResourceWithStreamingResponse
+
+        return LegalResourceWithStreamingResponse(self._client.legal)
+
     @cached_property
     def llm(self) -> llm.LlmResourceWithStreamingResponse:
         from .resources.llm import LlmResourceWithStreamingResponse
 
         return LlmResourceWithStreamingResponse(self._client.llm)
 
+    @cached_property
+    def memory(self) -> memory.MemoryResourceWithStreamingResponse:
+        from .resources.memory import MemoryResourceWithStreamingResponse
+
+        return MemoryResourceWithStreamingResponse(self._client.memory)
+
     @cached_property
     def ocr(self) -> ocr.OcrResourceWithStreamingResponse:
         from .resources.ocr import OcrResourceWithStreamingResponse
 
         return OcrResourceWithStreamingResponse(self._client.ocr)
 
+    @cached_property
+    def privilege(self) -> privilege.PrivilegeResourceWithStreamingResponse:
+        from .resources.privilege import PrivilegeResourceWithStreamingResponse
+
+        return PrivilegeResourceWithStreamingResponse(self._client.privilege)
+
     @cached_property
     def search(self) -> search.SearchResourceWithStreamingResponse:
         from .resources.search import SearchResourceWithStreamingResponse
 
         return SearchResourceWithStreamingResponse(self._client.search)
 
+    @cached_property
+    def superdoc(self) -> superdoc.SuperdocResourceWithStreamingResponse:
+        from .resources.superdoc import SuperdocResourceWithStreamingResponse
+
+        return SuperdocResourceWithStreamingResponse(self._client.superdoc)
+
+    @cached_property
+    def translate(self) -> translate.TranslateResourceWithStreamingResponse:
+        from .resources.translate import TranslateResourceWithStreamingResponse
+
+        return TranslateResourceWithStreamingResponse(self._client.translate)
+
     @cached_property
     def vault(self) -> vault.VaultResourceWithStreamingResponse:
         from .resources.vault import VaultResourceWithStreamingResponse
@@ -683,36 +915,78 @@ class AsyncCasedevWithStreamedResponse:
     def __init__(self, client: AsyncCasedev) -> None:
         self._client = client
 
+    @cached_property
+    def applications(self) -> applications.AsyncApplicationsResourceWithStreamingResponse:
+        from .resources.applications import AsyncApplicationsResourceWithStreamingResponse
+
+        return AsyncApplicationsResourceWithStreamingResponse(self._client.applications)
+
     @cached_property
     def compute(self) -> compute.AsyncComputeResourceWithStreamingResponse:
         from .resources.compute import AsyncComputeResourceWithStreamingResponse
 
         return AsyncComputeResourceWithStreamingResponse(self._client.compute)
 
+    @cached_property
+    def database(self) -> database.AsyncDatabaseResourceWithStreamingResponse:
+        from .resources.database import AsyncDatabaseResourceWithStreamingResponse
+
+        return AsyncDatabaseResourceWithStreamingResponse(self._client.database)
+
     @cached_property
     def format(self) -> format.AsyncFormatResourceWithStreamingResponse:
         from .resources.format import AsyncFormatResourceWithStreamingResponse
 
         return AsyncFormatResourceWithStreamingResponse(self._client.format)
 
+    @cached_property
+    def legal(self) -> legal.AsyncLegalResourceWithStreamingResponse:
+        from .resources.legal import AsyncLegalResourceWithStreamingResponse
+
+        return AsyncLegalResourceWithStreamingResponse(self._client.legal)
+
     @cached_property
     def llm(self) -> llm.AsyncLlmResourceWithStreamingResponse:
         from .resources.llm import AsyncLlmResourceWithStreamingResponse
 
         return AsyncLlmResourceWithStreamingResponse(self._client.llm)
 
+    @cached_property
+    def memory(self) -> memory.AsyncMemoryResourceWithStreamingResponse:
+        from .resources.memory import AsyncMemoryResourceWithStreamingResponse
+
+        return AsyncMemoryResourceWithStreamingResponse(self._client.memory)
+
     @cached_property
     def ocr(self) -> ocr.AsyncOcrResourceWithStreamingResponse:
         from .resources.ocr import AsyncOcrResourceWithStreamingResponse
 
         return AsyncOcrResourceWithStreamingResponse(self._client.ocr)
 
+    @cached_property
+    def privilege(self) -> privilege.AsyncPrivilegeResourceWithStreamingResponse:
+        from .resources.privilege import AsyncPrivilegeResourceWithStreamingResponse
+
+        return AsyncPrivilegeResourceWithStreamingResponse(self._client.privilege)
+
     @cached_property
     def search(self) -> search.AsyncSearchResourceWithStreamingResponse:
         from .resources.search import AsyncSearchResourceWithStreamingResponse
 
         return AsyncSearchResourceWithStreamingResponse(self._client.search)
 
+    @cached_property
+    def superdoc(self) -> superdoc.AsyncSuperdocResourceWithStreamingResponse:
+        from .resources.superdoc import AsyncSuperdocResourceWithStreamingResponse
+
+        return AsyncSuperdocResourceWithStreamingResponse(self._client.superdoc)
+
+    @cached_property
+    def translate(self) -> translate.AsyncTranslateResourceWithStreamingResponse:
+        from .resources.translate import AsyncTranslateResourceWithStreamingResponse
+
+        return AsyncTranslateResourceWithStreamingResponse(self._client.translate)
+
     @cached_property
     def vault(self) -> vault.AsyncVaultResourceWithStreamingResponse:
         from .resources.vault import AsyncVaultResourceWithStreamingResponse

casedev/_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)
         ),
     )
 

casedev/_utils/_json.py

@@ -0,0 +1,35 @@
+import json
+from typing import Any
+from datetime import datetime
+from typing_extensions import override
+
+import pydantic
+
+from .._compat import model_dump
+
+
+def openapi_dumps(obj: Any) -> bytes:
+    """
+    Serialize an object to UTF-8 encoded JSON bytes.
+
+    Extends the standard json.dumps with support for additional types
+    commonly used in the SDK, such as `datetime`, `pydantic.BaseModel`, etc.
+    """
+    return json.dumps(
+        obj,
+        cls=_CustomEncoder,
+        # Uses the same defaults as httpx's JSON serialization
+        ensure_ascii=False,
+        separators=(",", ":"),
+        allow_nan=False,
+    ).encode()
+
+
+class _CustomEncoder(json.JSONEncoder):
+    @override
+    def default(self, o: Any) -> Any:
+        if isinstance(o, datetime):
+            return o.isoformat()
+        if isinstance(o, pydantic.BaseModel):
+            return model_dump(o, exclude_unset=True, mode="json", by_alias=True)
+        return super().default(o)

casedev/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "casedev"
-__version__ = "0.2.0"  # x-release-please-version
+__version__ = "0.4.0"  # x-release-please-version