fix(stainless): added missing reranking endpoint to SDK API (#50)

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 1
+configured_endpoints: 2
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/isaacus%2Fisaacus-861e8a85f0fb73cf4b7fc6c2b27722072ff33109459e90c17be24af15dfcbd0c.yml
 openapi_spec_hash: 644a0383600633ee604bb1e5b9ca025d
-config_hash: 8a781867f31df68b9c6fba04c165c647
+config_hash: 2bc262108dc3b065c16da5bb85c1e282

api.md

@@ -11,3 +11,15 @@ from isaacus.types.classifications import UniversalClassification
 Methods:
 
 - <code title="post /classifications/universal">client.classifications.universal.<a href="./src/isaacus/resources/classifications/universal.py">create</a>(\*\*<a href="src/isaacus/types/classifications/universal_create_params.py">params</a>) -> <a href="./src/isaacus/types/classifications/universal_classification.py">UniversalClassification</a></code>
+
+# Rerankings
+
+Types:
+
+```python
+from isaacus.types import Reranking
+```
+
+Methods:
+
+- <code title="post /rerankings">client.rerankings.<a href="./src/isaacus/resources/rerankings.py">create</a>(\*\*<a href="src/isaacus/types/reranking_create_params.py">params</a>) -> <a href="./src/isaacus/types/reranking.py">Reranking</a></code>

src/isaacus/_client.py

@@ -24,6 +24,7 @@
     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 @@
 
 class Isaacus(SyncAPIClient):
     classifications: classifications.ClassificationsResource
+    rerankings: rerankings.RerankingsResource
     with_raw_response: IsaacusWithRawResponse
     with_streaming_response: IsaacusWithStreamedResponse
 
@@ -96,6 +98,7 @@ def __init__(
         )
 
         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 @@ def _make_status_error(
 
 class AsyncIsaacus(AsyncAPIClient):
     classifications: classifications.AsyncClassificationsResource
+    rerankings: rerankings.AsyncRerankingsResource
     with_raw_response: AsyncIsaacusWithRawResponse
     with_streaming_response: AsyncIsaacusWithStreamedResponse
 
@@ -264,6 +268,7 @@ def __init__(
         )
 
         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 @@ def _make_status_error(
 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

src/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 @@
     "AsyncClassificationsResourceWithRawResponse",
     "ClassificationsResourceWithStreamingResponse",
     "AsyncClassificationsResourceWithStreamingResponse",
+    "RerankingsResource",
+    "AsyncRerankingsResource",
+    "RerankingsResourceWithRawResponse",
+    "AsyncRerankingsResourceWithRawResponse",
+    "RerankingsResourceWithStreamingResponse",
+    "AsyncRerankingsResourceWithStreamingResponse",
 ]

src/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,
+        )