isaacus 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

isaacus/_client.py

@@ -24,6 +24,7 @@ from ._utils import (
     get_async_library,
 )
 from ._version import __version__
+from .resources import rerankings
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import IsaacusError, APIStatusError
 from ._base_client import (
@@ -38,6 +39,7 @@ __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Isaacus",
 
 class Isaacus(SyncAPIClient):
     classifications: classifications.ClassificationsResource
+    rerankings: rerankings.RerankingsResource
     with_raw_response: IsaacusWithRawResponse
     with_streaming_response: IsaacusWithStreamedResponse
 
@@ -96,6 +98,7 @@ class Isaacus(SyncAPIClient):
         )
 
         self.classifications = classifications.ClassificationsResource(self)
+        self.rerankings = rerankings.RerankingsResource(self)
         self.with_raw_response = IsaacusWithRawResponse(self)
         self.with_streaming_response = IsaacusWithStreamedResponse(self)
 
@@ -206,6 +209,7 @@ class Isaacus(SyncAPIClient):
 
 class AsyncIsaacus(AsyncAPIClient):
     classifications: classifications.AsyncClassificationsResource
+    rerankings: rerankings.AsyncRerankingsResource
     with_raw_response: AsyncIsaacusWithRawResponse
     with_streaming_response: AsyncIsaacusWithStreamedResponse
 
@@ -264,6 +268,7 @@ class AsyncIsaacus(AsyncAPIClient):
         )
 
         self.classifications = classifications.AsyncClassificationsResource(self)
+        self.rerankings = rerankings.AsyncRerankingsResource(self)
         self.with_raw_response = AsyncIsaacusWithRawResponse(self)
         self.with_streaming_response = AsyncIsaacusWithStreamedResponse(self)
 
@@ -375,21 +380,25 @@ class AsyncIsaacus(AsyncAPIClient):
 class IsaacusWithRawResponse:
     def __init__(self, client: Isaacus) -> None:
         self.classifications = classifications.ClassificationsResourceWithRawResponse(client.classifications)
+        self.rerankings = rerankings.RerankingsResourceWithRawResponse(client.rerankings)
 
 
 class AsyncIsaacusWithRawResponse:
     def __init__(self, client: AsyncIsaacus) -> None:
         self.classifications = classifications.AsyncClassificationsResourceWithRawResponse(client.classifications)
+        self.rerankings = rerankings.AsyncRerankingsResourceWithRawResponse(client.rerankings)
 
 
 class IsaacusWithStreamedResponse:
     def __init__(self, client: Isaacus) -> None:
         self.classifications = classifications.ClassificationsResourceWithStreamingResponse(client.classifications)
+        self.rerankings = rerankings.RerankingsResourceWithStreamingResponse(client.rerankings)
 
 
 class AsyncIsaacusWithStreamedResponse:
     def __init__(self, client: AsyncIsaacus) -> None:
         self.classifications = classifications.AsyncClassificationsResourceWithStreamingResponse(client.classifications)
+        self.rerankings = rerankings.AsyncRerankingsResourceWithStreamingResponse(client.rerankings)
 
 
 Client = Isaacus

isaacus/_version.py

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

isaacus/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .rerankings import (
+    RerankingsResource,
+    AsyncRerankingsResource,
+    RerankingsResourceWithRawResponse,
+    AsyncRerankingsResourceWithRawResponse,
+    RerankingsResourceWithStreamingResponse,
+    AsyncRerankingsResourceWithStreamingResponse,
+)
 from .classifications import (
     ClassificationsResource,
     AsyncClassificationsResource,
@@ -16,4 +24,10 @@ __all__ = [
     "AsyncClassificationsResourceWithRawResponse",
     "ClassificationsResourceWithStreamingResponse",
     "AsyncClassificationsResourceWithStreamingResponse",
+    "RerankingsResource",
+    "AsyncRerankingsResource",
+    "RerankingsResourceWithRawResponse",
+    "AsyncRerankingsResourceWithRawResponse",
+    "RerankingsResourceWithStreamingResponse",
+    "AsyncRerankingsResourceWithStreamingResponse",
 ]

isaacus/resources/rerankings.py

@@ -0,0 +1,285 @@
+# 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 reranking_create_params
+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.reranking import Reranking
+
+__all__ = ["RerankingsResource", "AsyncRerankingsResource"]
+
+
+class RerankingsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> RerankingsResourceWithRawResponse:
+        """
+        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 RerankingsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RerankingsResourceWithStreamingResponse:
+        """
+        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 RerankingsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        model: Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"],
+        query: str,
+        texts: List[str],
+        chunking_options: Optional[reranking_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,
+        top_n: Optional[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,
+    ) -> Reranking:
+        """
+        Rerank legal documents by their relevance to a query with an Isaacus legal AI
+        reranker.
+
+        Args:
+          model: The ID of the [model](https://docs.isaacus.com/models#reranking) to use for
+              reranking.
+
+          query: The query to evaluate the relevance of the texts to.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the texts being reranked, the query cannot be so long that it exceeds the
+              maximum input length of the reranker.
+
+          texts: The texts to rerank.
+
+              There must be at least one text.
+
+              The texts 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)](https://docs.isaacus.com/iql) query, which is not
+              the case by default.
+
+              If you allow untrusted users to construct their own queries, think carefully
+              before enabling IQL since queries can be crafted to consume an excessively large
+              amount of tokens.
+
+          scoring_method: The method to use for producing an overall relevance score for a text.
+
+              `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 inputs.
+
+              `chunk_max` uses the highest relevance score of all of a text's chunks.
+
+              `chunk_avg` averages the relevance scores of all of a text's chunks.
+
+              `chunk_min` uses the lowest relevance score of all of a text's chunks.
+
+          top_n: A whole number greater than or equal to 1.
+
+          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(
+            "/rerankings",
+            body=maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "texts": texts,
+                    "chunking_options": chunking_options,
+                    "is_iql": is_iql,
+                    "scoring_method": scoring_method,
+                    "top_n": top_n,
+                },
+                reranking_create_params.RerankingCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Reranking,
+        )
+
+
+class AsyncRerankingsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncRerankingsResourceWithRawResponse:
+        """
+        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 AsyncRerankingsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRerankingsResourceWithStreamingResponse:
+        """
+        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 AsyncRerankingsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        model: Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"],
+        query: str,
+        texts: List[str],
+        chunking_options: Optional[reranking_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,
+        top_n: Optional[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,
+    ) -> Reranking:
+        """
+        Rerank legal documents by their relevance to a query with an Isaacus legal AI
+        reranker.
+
+        Args:
+          model: The ID of the [model](https://docs.isaacus.com/models#reranking) to use for
+              reranking.
+
+          query: The query to evaluate the relevance of the texts to.
+
+              The query must contain at least one non-whitespace character.
+
+              Unlike the texts being reranked, the query cannot be so long that it exceeds the
+              maximum input length of the reranker.
+
+          texts: The texts to rerank.
+
+              There must be at least one text.
+
+              The texts 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)](https://docs.isaacus.com/iql) query, which is not
+              the case by default.
+
+              If you allow untrusted users to construct their own queries, think carefully
+              before enabling IQL since queries can be crafted to consume an excessively large
+              amount of tokens.
+
+          scoring_method: The method to use for producing an overall relevance score for a text.
+
+              `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 inputs.
+
+              `chunk_max` uses the highest relevance score of all of a text's chunks.
+
+              `chunk_avg` averages the relevance scores of all of a text's chunks.
+
+              `chunk_min` uses the lowest relevance score of all of a text's chunks.
+
+          top_n: A whole number greater than or equal to 1.
+
+          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(
+            "/rerankings",
+            body=await async_maybe_transform(
+                {
+                    "model": model,
+                    "query": query,
+                    "texts": texts,
+                    "chunking_options": chunking_options,
+                    "is_iql": is_iql,
+                    "scoring_method": scoring_method,
+                    "top_n": top_n,
+                },
+                reranking_create_params.RerankingCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Reranking,
+        )
+
+
+class RerankingsResourceWithRawResponse:
+    def __init__(self, rerankings: RerankingsResource) -> None:
+        self._rerankings = rerankings
+
+        self.create = to_raw_response_wrapper(
+            rerankings.create,
+        )
+
+
+class AsyncRerankingsResourceWithRawResponse:
+    def __init__(self, rerankings: AsyncRerankingsResource) -> None:
+        self._rerankings = rerankings
+
+        self.create = async_to_raw_response_wrapper(
+            rerankings.create,
+        )
+
+
+class RerankingsResourceWithStreamingResponse:
+    def __init__(self, rerankings: RerankingsResource) -> None:
+        self._rerankings = rerankings
+
+        self.create = to_streamed_response_wrapper(
+            rerankings.create,
+        )
+
+
+class AsyncRerankingsResourceWithStreamingResponse:
+    def __init__(self, rerankings: AsyncRerankingsResource) -> None:
+        self._rerankings = rerankings
+
+        self.create = async_to_streamed_response_wrapper(
+            rerankings.create,
+        )

isaacus/types/__init__.py

@@ -1,3 +1,6 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from __future__ import annotations
+
+from .reranking import Reranking as Reranking
+from .reranking_create_params import RerankingCreateParams as RerankingCreateParams

isaacus/types/reranking.py

@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .._models import BaseModel
+
+__all__ = ["Reranking", "Result", "Usage"]
+
+
+class Result(BaseModel):
+    index: int
+    """
+    The index of the text in the input array of texts, starting from `0` (and,
+    therefore, ending at the number of texts minus `1`).
+    """
+
+    score: float
+    """
+    A score between `0` and `1`, inclusive, representing the relevance of the text
+    to the query.
+    """
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens inputted to the model."""
+
+
+class Reranking(BaseModel):
+    results: List[Result]
+    """
+    The rerankings of the texts, by relevance to the query, in order from highest to
+    lowest relevance score.
+    """
+
+    usage: Usage
+    """Statistics about the usage of resources in the process of reranking the texts."""

isaacus/types/reranking_create_params.py

@@ -0,0 +1,75 @@
+# 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__ = ["RerankingCreateParams", "ChunkingOptions"]
+
+
+class RerankingCreateParams(TypedDict, total=False):
+    model: Required[Literal["kanon-universal-classifier", "kanon-universal-classifier-mini"]]
+    """
+    The ID of the [model](https://docs.isaacus.com/models#reranking) to use for
+    reranking.
+    """
+
+    query: Required[str]
+    """The query to evaluate the relevance of the texts to.
+
+    The query must contain at least one non-whitespace character.
+
+    Unlike the texts being reranked, the query cannot be so long that it exceeds the
+    maximum input length of the reranker.
+    """
+
+    texts: Required[List[str]]
+    """The texts to rerank.
+
+    There must be at least one text.
+
+    The texts 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)](https://docs.isaacus.com/iql) query, which is not
+    the case by default.
+
+    If you allow untrusted users to construct their own queries, think carefully
+    before enabling IQL since queries can be crafted to consume an excessively large
+    amount of tokens.
+    """
+
+    scoring_method: Literal["auto", "chunk_max", "chunk_avg", "chunk_min"]
+    """The method to use for producing an overall relevance score for a text.
+
+    `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 inputs.
+
+    `chunk_max` uses the highest relevance score of all of a text's chunks.
+
+    `chunk_avg` averages the relevance scores of all of a text's chunks.
+
+    `chunk_min` uses the lowest relevance score of all of a text's chunks.
+    """
+
+    top_n: Optional[int]
+    """A whole number greater than or equal to 1."""
+
+
+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-0.3.0.dist-info → isaacus-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: isaacus
-Version: 0.3.0
+Version: 0.3.2
 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

{isaacus-0.3.0.dist-info → isaacus-0.3.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 isaacus/__init__.py,sha256=Wgs-qjblN9tJvI22iWwi5CfiVvyn1drBPnTYhVj7cWk,2426
 isaacus/_base_client.py,sha256=ORZD1WjSTLicI9Bv0nJdIF7OGDv0Wl4ySK0ygQ9AjM8,64958
-isaacus/_client.py,sha256=6KsVmDsdSUmwEwF-4-KPWQ4E4HI0Mj_BEyZu3zEJAq4,15232
+isaacus/_client.py,sha256=aqn4G8onxd-CBS_Tgnr9QA41g6ltcIScHsuUo9U1JeU,15874
 isaacus/_compat.py,sha256=VWemUKbj6DDkQ-O4baSpHVLJafotzeXmCQGJugfVTIw,6580
 isaacus/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 isaacus/_exceptions.py,sha256=L82uluhizzc94VydHIaJkNxkcG-2DAe74tNhrE2eN2A,3222
@@ -11,7 +11,7 @@ isaacus/_resource.py,sha256=iP_oYhz5enCI58mK7hlwLoPMPh4Q5s8-KBv-jGfv2aM,1106
 isaacus/_response.py,sha256=5v-mAgiP6X9EBGBvTYVdwuDjikiha-dc1dYmadIraCU,28795
 isaacus/_streaming.py,sha256=tMBfwrfEFWm0v7vWFgjn_lizsoD70lPkYigIBuADaCM,10104
 isaacus/_types.py,sha256=WCRAb8jikEJoOi8nza8l5NnOTKgZlpmN5fkiHoKoY08,6144
-isaacus/_version.py,sha256=DaIpOsmJwTjZ7vjUdHGrS7xLPy7VQCqCka2YMC41GU4,159
+isaacus/_version.py,sha256=lrZSgvq8RF7Q1bFXCHyRo1dSWktXcDOtoYEDDxxNP_8,159
 isaacus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isaacus/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
 isaacus/_utils/_logs.py,sha256=rwa1Yzjbs2JaFn9KQ06rH5c_GSNa--BVwWnWhvvT1tY,777
@@ -23,15 +23,18 @@ isaacus/_utils/_transform.py,sha256=asrbdx4Pf5NupzaB8QdEjypW_DgHjjkpswHT0Jum4S0,
 isaacus/_utils/_typing.py,sha256=nTJz0jcrQbEgxwy4TtAkNxuU0QHHlmc6mQtA6vIR8tg,4501
 isaacus/_utils/_utils.py,sha256=8UmbPOy_AAr2uUjjFui-VZSrVBHRj6bfNEKRp5YZP2A,12004
 isaacus/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-isaacus/resources/__init__.py,sha256=KjFBnZ_h6ej57WNjlTujjO7TMNC1wVbFNA19ryus-P4,669
+isaacus/resources/__init__.py,sha256=N582fDHPnidiDhuxYlHKV_Io6WDNMI3HE8Yze3l8wqU,1171
+isaacus/resources/rerankings.py,sha256=rNVu33jDe-KxaXKS9ReyPrvSYUIbTfxVRMm8MoZc9uI,11187
 isaacus/resources/classifications/__init__.py,sha256=tYSnDm-o0CVuTC95VoNJzOqHsb8jTzYmW8hdwW14K60,1158
 isaacus/resources/classifications/classifications.py,sha256=Td5Gscg1PNJJeobxow_hJq_RicpFe3ibEYN0Gh3Kpsg,4018
 isaacus/resources/classifications/universal.py,sha256=bA577ocisYb_xS4OA53pM8ZITFprgbL7Wl6ruBqkccE,10656
-isaacus/types/__init__.py,sha256=OKfJYcKb4NObdiRObqJV_dOyDQ8feXekDUge2o_4pXQ,122
+isaacus/types/__init__.py,sha256=PswomxWpSak5TApm_28hneqI_l_g0-4NF5W6kdedI0Y,253
+isaacus/types/reranking.py,sha256=MQRUoH2UB185Q369H01jnvaT9pz4D9z0oOoz8oLMqjc,911
+isaacus/types/reranking_create_params.py,sha256=qJlXHbt4CxlBmdDpmqLC_VJ9ldTHBy4kxr1IwXxq4Es,2481
 isaacus/types/classifications/__init__.py,sha256=GX6WFRzjx9qcuJhdRZjFLJRYMM4d5J8F5N-BUq4ZgP0,296
 isaacus/types/classifications/universal_classification.py,sha256=Dmh03lcEzb5atmmdhNs99kPX9HQ1B_BaNKUojxu2nlA,1654
 isaacus/types/classifications/universal_create_params.py,sha256=fFhx7SfLPA36lwCYPEzrW2jr7hFlSFyVPqBzNcHXQ2w,2259
-isaacus-0.3.0.dist-info/METADATA,sha256=eMAYqLdyJ7c7Y4d8D-if6gAV7yWyjVZ8ry483UhlF0I,14296
-isaacus-0.3.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-isaacus-0.3.0.dist-info/licenses/LICENSE,sha256=lUen4LYVFVGEVXBsntBAPsQsOWgMkno1e9WfgWkpZ-k,11337
-isaacus-0.3.0.dist-info/RECORD,,
+isaacus-0.3.2.dist-info/METADATA,sha256=0WtxLj3xaSQs_bI2-h2c67VQweIan0DZugMAPTkOAEo,14296
+isaacus-0.3.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+isaacus-0.3.2.dist-info/licenses/LICENSE,sha256=lUen4LYVFVGEVXBsntBAPsQsOWgMkno1e9WfgWkpZ-k,11337
+isaacus-0.3.2.dist-info/RECORD,,