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

casedev/resources/privilege/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from .privilege import (
+    PrivilegeResource,
+    AsyncPrivilegeResource,
+    PrivilegeResourceWithRawResponse,
+    AsyncPrivilegeResourceWithRawResponse,
+    PrivilegeResourceWithStreamingResponse,
+    AsyncPrivilegeResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "V1Resource",
+    "AsyncV1Resource",
+    "V1ResourceWithRawResponse",
+    "AsyncV1ResourceWithRawResponse",
+    "V1ResourceWithStreamingResponse",
+    "AsyncV1ResourceWithStreamingResponse",
+    "PrivilegeResource",
+    "AsyncPrivilegeResource",
+    "PrivilegeResourceWithRawResponse",
+    "AsyncPrivilegeResourceWithRawResponse",
+    "PrivilegeResourceWithStreamingResponse",
+    "AsyncPrivilegeResourceWithStreamingResponse",
+]

casedev/resources/privilege/privilege.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["PrivilegeResource", "AsyncPrivilegeResource"]
+
+
+class PrivilegeResource(SyncAPIResource):
+    @cached_property
+    def v1(self) -> V1Resource:
+        return V1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> PrivilegeResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return PrivilegeResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PrivilegeResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return PrivilegeResourceWithStreamingResponse(self)
+
+
+class AsyncPrivilegeResource(AsyncAPIResource):
+    @cached_property
+    def v1(self) -> AsyncV1Resource:
+        return AsyncV1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncPrivilegeResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPrivilegeResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPrivilegeResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncPrivilegeResourceWithStreamingResponse(self)
+
+
+class PrivilegeResourceWithRawResponse:
+    def __init__(self, privilege: PrivilegeResource) -> None:
+        self._privilege = privilege
+
+    @cached_property
+    def v1(self) -> V1ResourceWithRawResponse:
+        return V1ResourceWithRawResponse(self._privilege.v1)
+
+
+class AsyncPrivilegeResourceWithRawResponse:
+    def __init__(self, privilege: AsyncPrivilegeResource) -> None:
+        self._privilege = privilege
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithRawResponse:
+        return AsyncV1ResourceWithRawResponse(self._privilege.v1)
+
+
+class PrivilegeResourceWithStreamingResponse:
+    def __init__(self, privilege: PrivilegeResource) -> None:
+        self._privilege = privilege
+
+    @cached_property
+    def v1(self) -> V1ResourceWithStreamingResponse:
+        return V1ResourceWithStreamingResponse(self._privilege.v1)
+
+
+class AsyncPrivilegeResourceWithStreamingResponse:
+    def __init__(self, privilege: AsyncPrivilegeResource) -> None:
+        self._privilege = privilege
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithStreamingResponse:
+        return AsyncV1ResourceWithStreamingResponse(self._privilege.v1)

casedev/resources/privilege/v1.py

@@ -0,0 +1,260 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..._base_client import make_request_options
+from ...types.privilege import v1_detect_params
+from ...types.privilege.v1_detect_response import V1DetectResponse
+
+__all__ = ["V1Resource", "AsyncV1Resource"]
+
+
+class V1Resource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> V1ResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return V1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> V1ResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return V1ResourceWithStreamingResponse(self)
+
+    def detect(
+        self,
+        *,
+        categories: List[Literal["attorney_client", "work_product", "common_interest", "litigation_hold"]]
+        | Omit = omit,
+        content: str | Omit = omit,
+        document_id: str | Omit = omit,
+        include_rationale: bool | Omit = omit,
+        jurisdiction: Literal["US-Federal"] | Omit = omit,
+        model: str | Omit = omit,
+        vault_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> V1DetectResponse:
+        """Analyzes text or vault documents for legal privilege.
+
+        Detects attorney-client
+        privilege, work product doctrine, common interest privilege, and litigation hold
+        materials.
+
+        Returns structured privilege flags with confidence scores and policy-friendly
+        rationale suitable for discovery workflows and privilege logs.
+
+        **Size Limit:** Maximum 200,000 characters (larger documents rejected).
+
+        **Permissions:** Requires `chat` permission. When using `document_id`, also
+        requires `vault` permission.
+
+        **Note:** When analyzing vault documents, results are automatically stored in
+        the document's `privilege_analysis` metadata field.
+
+        Args:
+          categories: Privilege categories to check. Defaults to all: attorney_client, work_product,
+              common_interest, litigation_hold
+
+          content: Text content to analyze (required if document_id not provided)
+
+          document_id: Vault object ID to analyze (required if content not provided)
+
+          include_rationale: Include detailed rationale for each category
+
+          jurisdiction: Jurisdiction for privilege rules
+
+          model: LLM model to use for analysis
+
+          vault_id: Vault ID (required when using document_id)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/privilege/v1/detect",
+            body=maybe_transform(
+                {
+                    "categories": categories,
+                    "content": content,
+                    "document_id": document_id,
+                    "include_rationale": include_rationale,
+                    "jurisdiction": jurisdiction,
+                    "model": model,
+                    "vault_id": vault_id,
+                },
+                v1_detect_params.V1DetectParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=V1DetectResponse,
+        )
+
+
+class AsyncV1Resource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncV1ResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncV1ResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncV1ResourceWithStreamingResponse(self)
+
+    async def detect(
+        self,
+        *,
+        categories: List[Literal["attorney_client", "work_product", "common_interest", "litigation_hold"]]
+        | Omit = omit,
+        content: str | Omit = omit,
+        document_id: str | Omit = omit,
+        include_rationale: bool | Omit = omit,
+        jurisdiction: Literal["US-Federal"] | Omit = omit,
+        model: str | Omit = omit,
+        vault_id: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> V1DetectResponse:
+        """Analyzes text or vault documents for legal privilege.
+
+        Detects attorney-client
+        privilege, work product doctrine, common interest privilege, and litigation hold
+        materials.
+
+        Returns structured privilege flags with confidence scores and policy-friendly
+        rationale suitable for discovery workflows and privilege logs.
+
+        **Size Limit:** Maximum 200,000 characters (larger documents rejected).
+
+        **Permissions:** Requires `chat` permission. When using `document_id`, also
+        requires `vault` permission.
+
+        **Note:** When analyzing vault documents, results are automatically stored in
+        the document's `privilege_analysis` metadata field.
+
+        Args:
+          categories: Privilege categories to check. Defaults to all: attorney_client, work_product,
+              common_interest, litigation_hold
+
+          content: Text content to analyze (required if document_id not provided)
+
+          document_id: Vault object ID to analyze (required if content not provided)
+
+          include_rationale: Include detailed rationale for each category
+
+          jurisdiction: Jurisdiction for privilege rules
+
+          model: LLM model to use for analysis
+
+          vault_id: Vault ID (required when using document_id)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/privilege/v1/detect",
+            body=await async_maybe_transform(
+                {
+                    "categories": categories,
+                    "content": content,
+                    "document_id": document_id,
+                    "include_rationale": include_rationale,
+                    "jurisdiction": jurisdiction,
+                    "model": model,
+                    "vault_id": vault_id,
+                },
+                v1_detect_params.V1DetectParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=V1DetectResponse,
+        )
+
+
+class V1ResourceWithRawResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+        self.detect = to_raw_response_wrapper(
+            v1.detect,
+        )
+
+
+class AsyncV1ResourceWithRawResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+        self.detect = async_to_raw_response_wrapper(
+            v1.detect,
+        )
+
+
+class V1ResourceWithStreamingResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+        self.detect = to_streamed_response_wrapper(
+            v1.detect,
+        )
+
+
+class AsyncV1ResourceWithStreamingResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+        self.detect = async_to_streamed_response_wrapper(
+            v1.detect,
+        )

casedev/resources/superdoc/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from .superdoc import (
+    SuperdocResource,
+    AsyncSuperdocResource,
+    SuperdocResourceWithRawResponse,
+    AsyncSuperdocResourceWithRawResponse,
+    SuperdocResourceWithStreamingResponse,
+    AsyncSuperdocResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "V1Resource",
+    "AsyncV1Resource",
+    "V1ResourceWithRawResponse",
+    "AsyncV1ResourceWithRawResponse",
+    "V1ResourceWithStreamingResponse",
+    "AsyncV1ResourceWithStreamingResponse",
+    "SuperdocResource",
+    "AsyncSuperdocResource",
+    "SuperdocResourceWithRawResponse",
+    "AsyncSuperdocResourceWithRawResponse",
+    "SuperdocResourceWithStreamingResponse",
+    "AsyncSuperdocResourceWithStreamingResponse",
+]

casedev/resources/superdoc/superdoc.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .v1 import (
+    V1Resource,
+    AsyncV1Resource,
+    V1ResourceWithRawResponse,
+    AsyncV1ResourceWithRawResponse,
+    V1ResourceWithStreamingResponse,
+    AsyncV1ResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["SuperdocResource", "AsyncSuperdocResource"]
+
+
+class SuperdocResource(SyncAPIResource):
+    @cached_property
+    def v1(self) -> V1Resource:
+        return V1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> SuperdocResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return SuperdocResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SuperdocResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return SuperdocResourceWithStreamingResponse(self)
+
+
+class AsyncSuperdocResource(AsyncAPIResource):
+    @cached_property
+    def v1(self) -> AsyncV1Resource:
+        return AsyncV1Resource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSuperdocResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSuperdocResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSuperdocResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/CaseMark/casedev-python#with_streaming_response
+        """
+        return AsyncSuperdocResourceWithStreamingResponse(self)
+
+
+class SuperdocResourceWithRawResponse:
+    def __init__(self, superdoc: SuperdocResource) -> None:
+        self._superdoc = superdoc
+
+    @cached_property
+    def v1(self) -> V1ResourceWithRawResponse:
+        return V1ResourceWithRawResponse(self._superdoc.v1)
+
+
+class AsyncSuperdocResourceWithRawResponse:
+    def __init__(self, superdoc: AsyncSuperdocResource) -> None:
+        self._superdoc = superdoc
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithRawResponse:
+        return AsyncV1ResourceWithRawResponse(self._superdoc.v1)
+
+
+class SuperdocResourceWithStreamingResponse:
+    def __init__(self, superdoc: SuperdocResource) -> None:
+        self._superdoc = superdoc
+
+    @cached_property
+    def v1(self) -> V1ResourceWithStreamingResponse:
+        return V1ResourceWithStreamingResponse(self._superdoc.v1)
+
+
+class AsyncSuperdocResourceWithStreamingResponse:
+    def __init__(self, superdoc: AsyncSuperdocResource) -> None:
+        self._superdoc = superdoc
+
+    @cached_property
+    def v1(self) -> AsyncV1ResourceWithStreamingResponse:
+        return AsyncV1ResourceWithStreamingResponse(self._superdoc.v1)