isaacus 0.1.0a1__py3-none-any.whl

isaacus/resources/classifications/universal.py

@@ -0,0 +1,263 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.classifications import universal_create_params
+from ...types.classifications.universal_classification import UniversalClassification
+
+__all__ = ["UniversalResource", "AsyncUniversalResource"]
+
+
+class UniversalResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> UniversalResourceWithRawResponse:
+        """
+        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/isaacus-dev/isaacus-python#accessing-raw-response-data-eg-headers
+        """
+        return UniversalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> UniversalResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/isaacus-dev/isaacus-python#with_streaming_response
+        """
+        return UniversalResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"],
+        query: str,
+        text: str,
+        chunking_options: Optional[universal_create_params.ChunkingOptions] | NotGiven = NOT_GIVEN,
+        is_iql: bool | NotGiven = NOT_GIVEN,
+        scoring_method: Literal["auto", "chunk_max", "chunk_avg", "chunk_min"] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> UniversalClassification:
+        """
+        Classify the relevance of a legal document to a query using an Isaacus universal
+        legal AI classifier.
+
+        Args:
+          model: The ID of the model to use for universal classification.
+
+          query: The Isaacus Query Language (IQL) query or, if IQL is disabled, the statement, to
+              evaluate the text against.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the text being classified, the query cannot be so long that it exceeds
+              the maximum input length of the universal classifier.
+
+          text: The text to classify.
+
+              The text must contain at least one non-whitespace character.
+
+          chunking_options: Options for how to split text into smaller chunks.
+
+          is_iql: Whether the query should be interpreted as an Isaacus Query Language (IQL) query
+              or else as a statement.
+
+          scoring_method: The method to use for producing an overall confidence score.
+
+              `auto` is the default scoring method and is recommended for most use cases.
+              Currently, it is equivalent to `chunk_max`. In the future, it will automatically
+              select the best method based on the model and input.
+
+              `chunk_max` uses the highest confidence score of all of the text's chunks.
+
+              `chunk_avg` averages the confidence scores of all of the text's chunks.
+
+              `chunk_min` uses the lowest confidence score of all of the text's chunks.
+
+          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(
+            "/classifications/universal",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "text": text,
+                    "chunking_options": chunking_options,
+                    "is_iql": is_iql,
+                    "scoring_method": scoring_method,
+                },
+                universal_create_params.UniversalCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UniversalClassification,
+        )
+
+
+class AsyncUniversalResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncUniversalResourceWithRawResponse:
+        """
+        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/isaacus-dev/isaacus-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncUniversalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncUniversalResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/isaacus-dev/isaacus-python#with_streaming_response
+        """
+        return AsyncUniversalResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"],
+        query: str,
+        text: str,
+        chunking_options: Optional[universal_create_params.ChunkingOptions] | NotGiven = NOT_GIVEN,
+        is_iql: bool | NotGiven = NOT_GIVEN,
+        scoring_method: Literal["auto", "chunk_max", "chunk_avg", "chunk_min"] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> UniversalClassification:
+        """
+        Classify the relevance of a legal document to a query using an Isaacus universal
+        legal AI classifier.
+
+        Args:
+          model: The ID of the model to use for universal classification.
+
+          query: The Isaacus Query Language (IQL) query or, if IQL is disabled, the statement, to
+              evaluate the text against.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the text being classified, the query cannot be so long that it exceeds
+              the maximum input length of the universal classifier.
+
+          text: The text to classify.
+
+              The text must contain at least one non-whitespace character.
+
+          chunking_options: Options for how to split text into smaller chunks.
+
+          is_iql: Whether the query should be interpreted as an Isaacus Query Language (IQL) query
+              or else as a statement.
+
+          scoring_method: The method to use for producing an overall confidence score.
+
+              `auto` is the default scoring method and is recommended for most use cases.
+              Currently, it is equivalent to `chunk_max`. In the future, it will automatically
+              select the best method based on the model and input.
+
+              `chunk_max` uses the highest confidence score of all of the text's chunks.
+
+              `chunk_avg` averages the confidence scores of all of the text's chunks.
+
+              `chunk_min` uses the lowest confidence score of all of the text's chunks.
+
+          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(
+            "/classifications/universal",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "text": text,
+                    "chunking_options": chunking_options,
+                    "is_iql": is_iql,
+                    "scoring_method": scoring_method,
+                },
+                universal_create_params.UniversalCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=UniversalClassification,
+        )
+
+
+class UniversalResourceWithRawResponse:
+    def __init__(self, universal: UniversalResource) -> None:
+        self._universal = universal
+
+        self.create = to_raw_response_wrapper(
+            universal.create,
+        )
+
+
+class AsyncUniversalResourceWithRawResponse:
+    def __init__(self, universal: AsyncUniversalResource) -> None:
+        self._universal = universal
+
+        self.create = async_to_raw_response_wrapper(
+            universal.create,
+        )
+
+
+class UniversalResourceWithStreamingResponse:
+    def __init__(self, universal: UniversalResource) -> None:
+        self._universal = universal
+
+        self.create = to_streamed_response_wrapper(
+            universal.create,
+        )
+
+
+class AsyncUniversalResourceWithStreamingResponse:
+    def __init__(self, universal: AsyncUniversalResource) -> None:
+        self._universal = universal
+
+        self.create = async_to_streamed_response_wrapper(
+            universal.create,
+        )

isaacus/types/__init__.py

@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations

isaacus/types/classifications/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .universal_create_params import UniversalCreateParams as UniversalCreateParams
+from .universal_classification import UniversalClassification as UniversalClassification

isaacus/types/classifications/universal_classification.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["UniversalClassification", "Chunk", "Usage"]
+
+
+class Chunk(BaseModel):
+    end: int
+    """The end index of the chunk in the original text."""
+
+    score: float
+    """
+    The model's score of the likelihood that the query expressed about the chunk is
+    supported by the chunk.
+
+    A score greater than `0.5` indicates that the chunk supports the query, while a
+    score less than `0.5` indicates that the chunk does not support the query.
+    """
+
+    start: int
+    """The start index of the chunk in the original text."""
+
+    text: str
+    """The text of the chunk."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens inputted to the model."""
+
+
+class UniversalClassification(BaseModel):
+    chunks: Optional[List[Chunk]] = None
+    """
+    The text as broken into chunks by
+    [semchunk](https://github.com/isaacus-dev/semchunk), each chunk with its own
+    confidence score.
+
+    If no chunking occurred, this will be `null`.
+    """
+
+    score: float
+    """
+    A score of the likelihood that the query expressed about the text is supported
+    by the text.
+
+    A score greater than `0.5` indicates that the text supports the query, while a
+    score less than `0.5` indicates that the text does not support the query.
+    """
+
+    usage: Usage
+    """Statistics about the usage of resources in the process of classifying the text."""

isaacus/types/classifications/universal_create_params.py

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["UniversalCreateParams", "ChunkingOptions"]
+
+
+class UniversalCreateParams(TypedDict, total=False):
+    model: Required[Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"]]
+    """The ID of the model to use for universal classification."""
+
+    query: Required[str]
+    """
+    The Isaacus Query Language (IQL) query or, if IQL is disabled, the statement, to
+    evaluate the text against.
+
+    The query must contain at least one non-whitespace character.
+
+    Unlike the text being classified, the query cannot be so long that it exceeds
+    the maximum input length of the universal classifier.
+    """
+
+    text: Required[str]
+    """The text to classify.
+
+    The text must contain at least one non-whitespace character.
+    """
+
+    chunking_options: Optional[ChunkingOptions]
+    """Options for how to split text into smaller chunks."""
+
+    is_iql: bool
+    """
+    Whether the query should be interpreted as an Isaacus Query Language (IQL) query
+    or else as a statement.
+    """
+
+    scoring_method: Literal["auto", "chunk_max", "chunk_avg", "chunk_min"]
+    """The method to use for producing an overall confidence score.
+
+    `auto` is the default scoring method and is recommended for most use cases.
+    Currently, it is equivalent to `chunk_max`. In the future, it will automatically
+    select the best method based on the model and input.
+
+    `chunk_max` uses the highest confidence score of all of the text's chunks.
+
+    `chunk_avg` averages the confidence scores of all of the text's chunks.
+
+    `chunk_min` uses the lowest confidence score of all of the text's chunks.
+    """
+
+
+class ChunkingOptions(TypedDict, total=False):
+    overlap_ratio: Optional[float]
+    """A number greater than or equal to 0 and less than 1."""
+
+    overlap_tokens: Optional[int]
+    """A whole number greater than -1."""
+
+    size: Optional[int]
+    """A whole number greater than or equal to 1."""