isaacus 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

isaacus/resources/__init__.py

@@ -8,6 +8,14 @@ from .rerankings import (
     RerankingsResourceWithStreamingResponse,
     AsyncRerankingsResourceWithStreamingResponse,
 )
+from .extractions import (
+    ExtractionsResource,
+    AsyncExtractionsResource,
+    ExtractionsResourceWithRawResponse,
+    AsyncExtractionsResourceWithRawResponse,
+    ExtractionsResourceWithStreamingResponse,
+    AsyncExtractionsResourceWithStreamingResponse,
+)
 from .classifications import (
     ClassificationsResource,
     AsyncClassificationsResource,
@@ -30,4 +38,10 @@ __all__ = [
     "AsyncRerankingsResourceWithRawResponse",
     "RerankingsResourceWithStreamingResponse",
     "AsyncRerankingsResourceWithStreamingResponse",
+    "ExtractionsResource",
+    "AsyncExtractionsResource",
+    "ExtractionsResourceWithRawResponse",
+    "AsyncExtractionsResourceWithRawResponse",
+    "ExtractionsResourceWithStreamingResponse",
+    "AsyncExtractionsResourceWithStreamingResponse",
 ]

isaacus/resources/classifications/universal.py

@@ -8,10 +8,7 @@ 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 ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -81,7 +78,7 @@ class UniversalResource(SyncAPIResource):
 
           texts: The texts to classify.
 
-              The texts must contain at least one non-whitespace character.
+              Each text must contain at least one non-whitespace character.
 
           chunking_options: Options for how to split text into smaller chunks.
 
@@ -182,7 +179,7 @@ class AsyncUniversalResource(AsyncAPIResource):
 
           texts: The texts to classify.
 
-              The texts must contain at least one non-whitespace character.
+              Each text must contain at least one non-whitespace character.
 
           chunking_options: Options for how to split text into smaller chunks.
 

isaacus/resources/extractions/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .qa import (
+    QaResource,
+    AsyncQaResource,
+    QaResourceWithRawResponse,
+    AsyncQaResourceWithRawResponse,
+    QaResourceWithStreamingResponse,
+    AsyncQaResourceWithStreamingResponse,
+)
+from .extractions import (
+    ExtractionsResource,
+    AsyncExtractionsResource,
+    ExtractionsResourceWithRawResponse,
+    AsyncExtractionsResourceWithRawResponse,
+    ExtractionsResourceWithStreamingResponse,
+    AsyncExtractionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "QaResource",
+    "AsyncQaResource",
+    "QaResourceWithRawResponse",
+    "AsyncQaResourceWithRawResponse",
+    "QaResourceWithStreamingResponse",
+    "AsyncQaResourceWithStreamingResponse",
+    "ExtractionsResource",
+    "AsyncExtractionsResource",
+    "ExtractionsResourceWithRawResponse",
+    "AsyncExtractionsResourceWithRawResponse",
+    "ExtractionsResourceWithStreamingResponse",
+    "AsyncExtractionsResourceWithStreamingResponse",
+]

isaacus/resources/extractions/extractions.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .qa import (
+    QaResource,
+    AsyncQaResource,
+    QaResourceWithRawResponse,
+    AsyncQaResourceWithRawResponse,
+    QaResourceWithStreamingResponse,
+    AsyncQaResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["ExtractionsResource", "AsyncExtractionsResource"]
+
+
+class ExtractionsResource(SyncAPIResource):
+    @cached_property
+    def qa(self) -> QaResource:
+        return QaResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ExtractionsResourceWithRawResponse:
+        """
+        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 ExtractionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExtractionsResourceWithStreamingResponse:
+        """
+        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 ExtractionsResourceWithStreamingResponse(self)
+
+
+class AsyncExtractionsResource(AsyncAPIResource):
+    @cached_property
+    def qa(self) -> AsyncQaResource:
+        return AsyncQaResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncExtractionsResourceWithRawResponse:
+        """
+        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 AsyncExtractionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExtractionsResourceWithStreamingResponse:
+        """
+        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 AsyncExtractionsResourceWithStreamingResponse(self)
+
+
+class ExtractionsResourceWithRawResponse:
+    def __init__(self, extractions: ExtractionsResource) -> None:
+        self._extractions = extractions
+
+    @cached_property
+    def qa(self) -> QaResourceWithRawResponse:
+        return QaResourceWithRawResponse(self._extractions.qa)
+
+
+class AsyncExtractionsResourceWithRawResponse:
+    def __init__(self, extractions: AsyncExtractionsResource) -> None:
+        self._extractions = extractions
+
+    @cached_property
+    def qa(self) -> AsyncQaResourceWithRawResponse:
+        return AsyncQaResourceWithRawResponse(self._extractions.qa)
+
+
+class ExtractionsResourceWithStreamingResponse:
+    def __init__(self, extractions: ExtractionsResource) -> None:
+        self._extractions = extractions
+
+    @cached_property
+    def qa(self) -> QaResourceWithStreamingResponse:
+        return QaResourceWithStreamingResponse(self._extractions.qa)
+
+
+class AsyncExtractionsResourceWithStreamingResponse:
+    def __init__(self, extractions: AsyncExtractionsResource) -> None:
+        self._extractions = extractions
+
+    @cached_property
+    def qa(self) -> AsyncQaResourceWithStreamingResponse:
+        return AsyncQaResourceWithStreamingResponse(self._extractions.qa)

isaacus/resources/extractions/qa.py

@@ -0,0 +1,258 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, 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.extractions import qa_create_params
+from ...types.extractions.answer_extraction import AnswerExtraction
+
+__all__ = ["QaResource", "AsyncQaResource"]
+
+
+class QaResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> QaResourceWithRawResponse:
+        """
+        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 QaResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> QaResourceWithStreamingResponse:
+        """
+        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 QaResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: Literal["kanon-answer-extractor", "kanon-answer-extractor-mini"],
+        query: str,
+        texts: List[str],
+        chunking_options: Optional[qa_create_params.ChunkingOptions] | NotGiven = NOT_GIVEN,
+        ignore_inextractability: bool | NotGiven = NOT_GIVEN,
+        top_k: int | 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,
+    ) -> AnswerExtraction:
+        """
+        Extract answers to questions from legal documents with an Isaacus legal AI
+        answer extractor.
+
+        Args:
+          model: The ID of the [model](https://docs.isaacus.com/models#extractive-qa) to use for
+              extractive question answering.
+
+          query: The query to extract the answer to.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the texts from which the answer will be extracted, the query cannot be so
+              long that it exceeds the maximum input length of the model.
+
+          texts: The texts to search for the answer in and extract the answer from.
+
+              There must be at least one text.
+
+              Each text must contain at least one non-whitespace character.
+
+          chunking_options: Options for how to split text into smaller chunks.
+
+          ignore_inextractability: Whether to, if the model's score of the likelihood that an answer can not be
+              extracted from a text is greater than the highest score of all possible answers,
+              still return the highest scoring answers for that text.
+
+              If you have already determined that the texts answer the query, for example, by
+              using one of our classification or reranker models, then you should set this to
+              `true`.
+
+          top_k: The number of highest scoring answers to return.
+
+              If `null`, which is the default, all answers will be returned.
+
+          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(
+            "/extractions/qa",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "texts": texts,
+                    "chunking_options": chunking_options,
+                    "ignore_inextractability": ignore_inextractability,
+                    "top_k": top_k,
+                },
+                qa_create_params.QaCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AnswerExtraction,
+        )
+
+
+class AsyncQaResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncQaResourceWithRawResponse:
+        """
+        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 AsyncQaResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncQaResourceWithStreamingResponse:
+        """
+        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 AsyncQaResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: Literal["kanon-answer-extractor", "kanon-answer-extractor-mini"],
+        query: str,
+        texts: List[str],
+        chunking_options: Optional[qa_create_params.ChunkingOptions] | NotGiven = NOT_GIVEN,
+        ignore_inextractability: bool | NotGiven = NOT_GIVEN,
+        top_k: int | 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,
+    ) -> AnswerExtraction:
+        """
+        Extract answers to questions from legal documents with an Isaacus legal AI
+        answer extractor.
+
+        Args:
+          model: The ID of the [model](https://docs.isaacus.com/models#extractive-qa) to use for
+              extractive question answering.
+
+          query: The query to extract the answer to.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the texts from which the answer will be extracted, the query cannot be so
+              long that it exceeds the maximum input length of the model.
+
+          texts: The texts to search for the answer in and extract the answer from.
+
+              There must be at least one text.
+
+              Each text must contain at least one non-whitespace character.
+
+          chunking_options: Options for how to split text into smaller chunks.
+
+          ignore_inextractability: Whether to, if the model's score of the likelihood that an answer can not be
+              extracted from a text is greater than the highest score of all possible answers,
+              still return the highest scoring answers for that text.
+
+              If you have already determined that the texts answer the query, for example, by
+              using one of our classification or reranker models, then you should set this to
+              `true`.
+
+          top_k: The number of highest scoring answers to return.
+
+              If `null`, which is the default, all answers will be returned.
+
+          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(
+            "/extractions/qa",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "texts": texts,
+                    "chunking_options": chunking_options,
+                    "ignore_inextractability": ignore_inextractability,
+                    "top_k": top_k,
+                },
+                qa_create_params.QaCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=AnswerExtraction,
+        )
+
+
+class QaResourceWithRawResponse:
+    def __init__(self, qa: QaResource) -> None:
+        self._qa = qa
+
+        self.create = to_raw_response_wrapper(
+            qa.create,
+        )
+
+
+class AsyncQaResourceWithRawResponse:
+    def __init__(self, qa: AsyncQaResource) -> None:
+        self._qa = qa
+
+        self.create = async_to_raw_response_wrapper(
+            qa.create,
+        )
+
+
+class QaResourceWithStreamingResponse:
+    def __init__(self, qa: QaResource) -> None:
+        self._qa = qa
+
+        self.create = to_streamed_response_wrapper(
+            qa.create,
+        )
+
+
+class AsyncQaResourceWithStreamingResponse:
+    def __init__(self, qa: AsyncQaResource) -> None:
+        self._qa = qa
+
+        self.create = async_to_streamed_response_wrapper(
+            qa.create,
+        )

isaacus/resources/rerankings.py

@@ -9,10 +9,7 @@ import httpx
 
 from ..types import reranking_create_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
-    maybe_transform,
-    async_maybe_transform,
-)
+from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -83,7 +80,7 @@ class RerankingsResource(SyncAPIResource):
 
               There must be at least one text.
 
-              The texts must contain at least one non-whitespace character.
+              Each text must contain at least one non-whitespace character.
 
           chunking_options: Options for how to split text into smaller chunks.
 
@@ -194,7 +191,7 @@ class AsyncRerankingsResource(AsyncAPIResource):
 
               There must be at least one text.
 
-              The texts must contain at least one non-whitespace character.
+              Each text must contain at least one non-whitespace character.
 
           chunking_options: Options for how to split text into smaller chunks.
 

isaacus/types/classifications/universal_create_params.py

@@ -29,7 +29,7 @@ class UniversalCreateParams(TypedDict, total=False):
     texts: Required[List[str]]
     """The texts to classify.
 
-    The texts must contain at least one non-whitespace character.
+    Each text must contain at least one non-whitespace character.
     """
 
     chunking_options: Optional[ChunkingOptions]

isaacus/types/extractions/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .qa_create_params import QaCreateParams as QaCreateParams
+from .answer_extraction import AnswerExtraction as AnswerExtraction

isaacus/types/extractions/answer_extraction.py

@@ -0,0 +1,71 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+
+__all__ = ["AnswerExtraction", "Extraction", "ExtractionAnswer", "Usage"]
+
+
+class ExtractionAnswer(BaseModel):
+    end: int
+    """
+    The index of the character immediately after the last character of the answer in
+    the text, starting from `0` (such that, in Python, the answer is equivalent to
+    `text[start:end]`).
+    """
+
+    score: float
+    """
+    A score between `0` and `1`, inclusive, representing the strength of the answer.
+    """
+
+    start: int
+    """
+    The index of the first character of the answer in the text, starting from `0`
+    (and, therefore, ending at the number of characters in the text minus `1`).
+    """
+
+    text: str
+    """The text of the answer."""
+
+
+class Extraction(BaseModel):
+    answers: List[ExtractionAnswer]
+    """Answers extracted from the text, ordered from highest to lowest score."""
+
+    index: int
+    """
+    The index of the text in the input array of texts that this result represents,
+    starting from `0` (and, therefore, ending at the number of texts minus `1`).
+    """
+
+    inextractability_score: float
+    """
+    A score between `0` and `1`, inclusive, representing the likelihood that an
+    answer can not be extracted from the text.
+
+    Where this score is greater than the highest score of all possible answers, the
+    text should be regarded as not having an extractable answer to the query. If
+    that is the case and `ignore_inextractability` is `false`, no answers will be
+    returned.
+    """
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens inputted to the model."""
+
+
+class AnswerExtraction(BaseModel):
+    extractions: List[Extraction]
+    """
+    The results of extracting answers from the texts, ordered from highest to lowest
+    inextractability score.
+    """
+
+    usage: Usage
+    """
+    Statistics about the usage of resources in the process of extracting answers
+    from the texts.
+    """

isaacus/types/extractions/qa_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 List, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["QaCreateParams", "ChunkingOptions"]
+
+
+class QaCreateParams(TypedDict, total=False):
+    model: Required[Literal["kanon-answer-extractor", "kanon-answer-extractor-mini"]]
+    """
+    The ID of the [model](https://docs.isaacus.com/models#extractive-qa) to use for
+    extractive question answering.
+    """
+
+    query: Required[str]
+    """The query to extract the answer to.
+
+    The query must contain at least one non-whitespace character.
+
+    Unlike the texts from which the answer will be extracted, the query cannot be so
+    long that it exceeds the maximum input length of the model.
+    """
+
+    texts: Required[List[str]]
+    """The texts to search for the answer in and extract the answer from.
+
+    There must be at least one text.
+
+    Each text must contain at least one non-whitespace character.
+    """
+
+    chunking_options: Optional[ChunkingOptions]
+    """Options for how to split text into smaller chunks."""
+
+    ignore_inextractability: bool
+    """
+    Whether to, if the model's score of the likelihood that an answer can not be
+    extracted from a text is greater than the highest score of all possible answers,
+    still return the highest scoring answers for that text.
+
+    If you have already determined that the texts answer the query, for example, by
+    using one of our classification or reranker models, then you should set this to
+    `true`.
+    """
+
+    top_k: int
+    """The number of highest scoring answers to return.
+
+    If `null`, which is the default, all answers will be returned.
+    """
+
+
+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."""

isaacus/types/reranking_create_params.py

@@ -29,7 +29,7 @@ class RerankingCreateParams(TypedDict, total=False):
 
     There must be at least one text.
 
-    The texts must contain at least one non-whitespace character.
+    Each text must contain at least one non-whitespace character.
     """
 
     chunking_options: Optional[ChunkingOptions]

{isaacus-0.5.0.dist-info → isaacus-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: isaacus
-Version: 0.5.0
+Version: 0.6.0
 Summary: The official Python library for the isaacus API
 Project-URL: Homepage, https://github.com/isaacus-dev/isaacus-python
 Project-URL: Repository, https://github.com/isaacus-dev/isaacus-python