casedev 0.1.0__py3-none-any.whl

casedev/resources/format/v1/templates.py

@@ -0,0 +1,419 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ...._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, 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.format.v1 import template_list_params, template_create_params
+from ....types.format.v1.template_create_response import TemplateCreateResponse
+
+__all__ = ["TemplatesResource", "AsyncTemplatesResource"]
+
+
+class TemplatesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TemplatesResourceWithRawResponse:
+        """
+        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 TemplatesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TemplatesResourceWithStreamingResponse:
+        """
+        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 TemplatesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        content: str,
+        name: str,
+        type: Literal["caption", "signature", "letterhead", "certificate", "footer", "custom"],
+        description: str | Omit = omit,
+        styles: object | Omit = omit,
+        tags: SequenceNotStr[str] | Omit = omit,
+        variables: SequenceNotStr[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,
+    ) -> TemplateCreateResponse:
+        """Create a new format template for document formatting.
+
+        Templates support
+        variables using `{{variable}}` syntax and can be used for captions, signatures,
+        letterheads, certificates, footers, or custom formatting needs.
+
+        Args:
+          content: Template content with {{variable}} placeholders
+
+          name: Template name
+
+          type: Template type
+
+          description: Template description
+
+          styles: CSS styles for the template
+
+          tags: Template tags for organization
+
+          variables: Template variables (auto-detected if not provided)
+
+          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(
+            "/format/v1/templates",
+            body=maybe_transform(
+                {
+                    "content": content,
+                    "name": name,
+                    "type": type,
+                    "description": description,
+                    "styles": styles,
+                    "tags": tags,
+                    "variables": variables,
+                },
+                template_create_params.TemplateCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TemplateCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        id: str,
+        *,
+        # 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,
+    ) -> None:
+        """Retrieve a specific document format template by ID.
+
+        Format templates define how
+        documents should be structured and formatted for specific legal use cases such
+        as contracts, briefs, or pleadings.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            f"/format/v1/templates/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def list(
+        self,
+        *,
+        type: 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,
+    ) -> None:
+        """Retrieve all format templates for the organization.
+
+        Templates define reusable
+        document formatting patterns with customizable variables for consistent legal
+        document generation.
+
+        Filter by type to get specific template categories like contracts, pleadings, or
+        correspondence.
+
+        Args:
+          type: Filter templates by type (e.g., contract, pleading, letter)
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._get(
+            "/format/v1/templates",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"type": type}, template_list_params.TemplateListParams),
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncTemplatesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTemplatesResourceWithRawResponse:
+        """
+        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 AsyncTemplatesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTemplatesResourceWithStreamingResponse:
+        """
+        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 AsyncTemplatesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        content: str,
+        name: str,
+        type: Literal["caption", "signature", "letterhead", "certificate", "footer", "custom"],
+        description: str | Omit = omit,
+        styles: object | Omit = omit,
+        tags: SequenceNotStr[str] | Omit = omit,
+        variables: SequenceNotStr[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,
+    ) -> TemplateCreateResponse:
+        """Create a new format template for document formatting.
+
+        Templates support
+        variables using `{{variable}}` syntax and can be used for captions, signatures,
+        letterheads, certificates, footers, or custom formatting needs.
+
+        Args:
+          content: Template content with {{variable}} placeholders
+
+          name: Template name
+
+          type: Template type
+
+          description: Template description
+
+          styles: CSS styles for the template
+
+          tags: Template tags for organization
+
+          variables: Template variables (auto-detected if not provided)
+
+          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(
+            "/format/v1/templates",
+            body=await async_maybe_transform(
+                {
+                    "content": content,
+                    "name": name,
+                    "type": type,
+                    "description": description,
+                    "styles": styles,
+                    "tags": tags,
+                    "variables": variables,
+                },
+                template_create_params.TemplateCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TemplateCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        id: str,
+        *,
+        # 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,
+    ) -> None:
+        """Retrieve a specific document format template by ID.
+
+        Format templates define how
+        documents should be structured and formatted for specific legal use cases such
+        as contracts, briefs, or pleadings.
+
+        Args:
+          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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            f"/format/v1/templates/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def list(
+        self,
+        *,
+        type: 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,
+    ) -> None:
+        """Retrieve all format templates for the organization.
+
+        Templates define reusable
+        document formatting patterns with customizable variables for consistent legal
+        document generation.
+
+        Filter by type to get specific template categories like contracts, pleadings, or
+        correspondence.
+
+        Args:
+          type: Filter templates by type (e.g., contract, pleading, letter)
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._get(
+            "/format/v1/templates",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"type": type}, template_list_params.TemplateListParams),
+            ),
+            cast_to=NoneType,
+        )
+
+
+class TemplatesResourceWithRawResponse:
+    def __init__(self, templates: TemplatesResource) -> None:
+        self._templates = templates
+
+        self.create = to_raw_response_wrapper(
+            templates.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            templates.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            templates.list,
+        )
+
+
+class AsyncTemplatesResourceWithRawResponse:
+    def __init__(self, templates: AsyncTemplatesResource) -> None:
+        self._templates = templates
+
+        self.create = async_to_raw_response_wrapper(
+            templates.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            templates.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            templates.list,
+        )
+
+
+class TemplatesResourceWithStreamingResponse:
+    def __init__(self, templates: TemplatesResource) -> None:
+        self._templates = templates
+
+        self.create = to_streamed_response_wrapper(
+            templates.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            templates.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            templates.list,
+        )
+
+
+class AsyncTemplatesResourceWithStreamingResponse:
+    def __init__(self, templates: AsyncTemplatesResource) -> None:
+        self._templates = templates
+
+        self.create = async_to_streamed_response_wrapper(
+            templates.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            templates.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            templates.list,
+        )

casedev/resources/format/v1/v1.py

@@ -0,0 +1,244 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+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 .templates import (
+    TemplatesResource,
+    AsyncTemplatesResource,
+    TemplatesResourceWithRawResponse,
+    AsyncTemplatesResourceWithRawResponse,
+    TemplatesResourceWithStreamingResponse,
+    AsyncTemplatesResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    BinaryAPIResponse,
+    AsyncBinaryAPIResponse,
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_custom_raw_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_raw_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
+)
+from ...._base_client import make_request_options
+from ....types.format import v1_create_document_params
+
+__all__ = ["V1Resource", "AsyncV1Resource"]
+
+
+class V1Resource(SyncAPIResource):
+    @cached_property
+    def templates(self) -> TemplatesResource:
+        return TemplatesResource(self._client)
+
+    @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 create_document(
+        self,
+        *,
+        content: str,
+        output_format: Literal["pdf", "docx", "html_preview"],
+        input_format: Literal["md", "json", "text"] | Omit = omit,
+        options: v1_create_document_params.Options | 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,
+    ) -> BinaryAPIResponse:
+        """
+        Convert Markdown, JSON, or text content to professionally formatted PDF, DOCX,
+        or HTML documents. Supports template components with variable interpolation for
+        creating consistent legal documents like contracts, briefs, and reports.
+
+        Args:
+          content: The source content to format
+
+          output_format: Desired output format
+
+          input_format: Format of the input content
+
+          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
+        """
+        extra_headers = {"Accept": "application/pdf", **(extra_headers or {})}
+        return self._post(
+            "/format/v1/document",
+            body=maybe_transform(
+                {
+                    "content": content,
+                    "output_format": output_format,
+                    "input_format": input_format,
+                    "options": options,
+                },
+                v1_create_document_params.V1CreateDocumentParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BinaryAPIResponse,
+        )
+
+
+class AsyncV1Resource(AsyncAPIResource):
+    @cached_property
+    def templates(self) -> AsyncTemplatesResource:
+        return AsyncTemplatesResource(self._client)
+
+    @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 create_document(
+        self,
+        *,
+        content: str,
+        output_format: Literal["pdf", "docx", "html_preview"],
+        input_format: Literal["md", "json", "text"] | Omit = omit,
+        options: v1_create_document_params.Options | 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,
+    ) -> AsyncBinaryAPIResponse:
+        """
+        Convert Markdown, JSON, or text content to professionally formatted PDF, DOCX,
+        or HTML documents. Supports template components with variable interpolation for
+        creating consistent legal documents like contracts, briefs, and reports.
+
+        Args:
+          content: The source content to format
+
+          output_format: Desired output format
+
+          input_format: Format of the input content
+
+          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
+        """
+        extra_headers = {"Accept": "application/pdf", **(extra_headers or {})}
+        return await self._post(
+            "/format/v1/document",
+            body=await async_maybe_transform(
+                {
+                    "content": content,
+                    "output_format": output_format,
+                    "input_format": input_format,
+                    "options": options,
+                },
+                v1_create_document_params.V1CreateDocumentParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AsyncBinaryAPIResponse,
+        )
+
+
+class V1ResourceWithRawResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+        self.create_document = to_custom_raw_response_wrapper(
+            v1.create_document,
+            BinaryAPIResponse,
+        )
+
+    @cached_property
+    def templates(self) -> TemplatesResourceWithRawResponse:
+        return TemplatesResourceWithRawResponse(self._v1.templates)
+
+
+class AsyncV1ResourceWithRawResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+        self.create_document = async_to_custom_raw_response_wrapper(
+            v1.create_document,
+            AsyncBinaryAPIResponse,
+        )
+
+    @cached_property
+    def templates(self) -> AsyncTemplatesResourceWithRawResponse:
+        return AsyncTemplatesResourceWithRawResponse(self._v1.templates)
+
+
+class V1ResourceWithStreamingResponse:
+    def __init__(self, v1: V1Resource) -> None:
+        self._v1 = v1
+
+        self.create_document = to_custom_streamed_response_wrapper(
+            v1.create_document,
+            StreamedBinaryAPIResponse,
+        )
+
+    @cached_property
+    def templates(self) -> TemplatesResourceWithStreamingResponse:
+        return TemplatesResourceWithStreamingResponse(self._v1.templates)
+
+
+class AsyncV1ResourceWithStreamingResponse:
+    def __init__(self, v1: AsyncV1Resource) -> None:
+        self._v1 = v1
+
+        self.create_document = async_to_custom_streamed_response_wrapper(
+            v1.create_document,
+            AsyncStreamedBinaryAPIResponse,
+        )
+
+    @cached_property
+    def templates(self) -> AsyncTemplatesResourceWithStreamingResponse:
+        return AsyncTemplatesResourceWithStreamingResponse(self._v1.templates)

casedev/resources/llm/__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 .llm import (
+    LlmResource,
+    AsyncLlmResource,
+    LlmResourceWithRawResponse,
+    AsyncLlmResourceWithRawResponse,
+    LlmResourceWithStreamingResponse,
+    AsyncLlmResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "V1Resource",
+    "AsyncV1Resource",
+    "V1ResourceWithRawResponse",
+    "AsyncV1ResourceWithRawResponse",
+    "V1ResourceWithStreamingResponse",
+    "AsyncV1ResourceWithStreamingResponse",
+    "LlmResource",
+    "AsyncLlmResource",
+    "LlmResourceWithRawResponse",
+    "AsyncLlmResourceWithRawResponse",
+    "LlmResourceWithStreamingResponse",
+    "AsyncLlmResourceWithStreamingResponse",
+]