isaacus 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

isaacus/types/external_document.py

@@ -0,0 +1,101 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["ExternalDocument"]
+
+
+class ExternalDocument(BaseModel):
+    """A document identified within another document."""
+
+    id: str
+    """
+    The unique identifier of the external document in the format `exd:{index}` where
+    `{index}` is a non-negative incrementing integer starting from zero.
+    """
+
+    name: Span
+    """A zero-based, half-open span into the Unicode code point space of input text.
+
+    All spans are globally laminar and well-nested similar to XML—it is impossible
+    for any two spans to partially overlap; they can only be disjoint, adjacent, or
+    wholly nested. Spans of the exact same type (e.g., segments) will never be
+    duplicated.
+
+    A span cannot be empty and will never start or end at whitespace.
+
+    Note that, when using programming languages other than Python (which uses
+    zero-based, half-open, Unicode code point-spaced string indexing), indices may
+    need to be translated accordingly (for example, JavaScript slices into UTF-16
+    code units instead of Unicode code points).
+    """
+
+    type: Literal["statute", "regulation", "decision", "contract", "other"]
+    """
+    The type of the external document, being one of `statute`, `regulation`,
+    `decision`, `contract`, or `other`.
+
+    `statute` denotes primary legislation such as acts, bills, codes, and
+    constitutions.
+
+    `regulation` denotes secondary legislation such as rules, statutory instruments,
+    and ordinances.
+
+    `decision` denotes judicial or quasi-judicial decisions such as court judgments,
+    judicial opinions, and tribunal rulings.
+
+    `other` is used for all other types of legal documents that do not fit into any
+    of the predefined types.
+    """
+
+    jurisdiction: Optional[str] = None
+    """
+    A jurisdiction code representing a country (via an initial country code) and,
+    optionally, a subdivision within that country (via a subsequent subdivision code
+    prefixed by a hyphen).
+
+    All 249 ISO 3166-1 alpha-2 country codes are representable in addition to
+    special `INT` and `EU` codes for international and European Union law,
+    respectively.
+
+    All 5,046 ISO 3166-2 codes are also representable in addition to a special `FED`
+    code for federal law.
+    """
+
+    reception: Literal["positive", "mixed", "negative", "neutral"]
+    """
+    The sentiment of the document towards the external document, being one of
+    `positive`, `mixed`, `negative`, or `neutral`.
+
+    `positive` indicates that the document expresses a favorable view of the
+    external document whether by endorsing or approving it.
+
+    `mixed` indicates that the document expresses both favorable and unfavorable
+    views of the external document, for example, by affirming parts of it and
+    disapproving others.
+
+    `negative` indicates that the document expresses an unfavorable view of the
+    external document whether by criticizing, repealing, overruling, or explicitly
+    contradicting it.
+
+    `neutral` indicates that the document references the external document without
+    expressing any particular sentiment towards it.
+    """
+
+    mentions: List[Span]
+    """
+    An array of one or more spans within the document's text where the external
+    document is mentioned by name, for example, 'the US Constitution' in 'the Second
+    Amendment to the US Constitution protects freedom of speech'.
+    """
+
+    pinpoints: List[Span]
+    """
+    An array of spans within the document's text where specific parts of the
+    external document are referenced, for example, 'Section 2' in 'as defined in
+    Section 2 of the US Constitution'.
+    """

isaacus/types/extractions/__init__.py

@@ -2,5 +2,5 @@
 
 from __future__ import annotations
 
-from .qa_create_params import QaCreateParams as QaCreateParams
+from .qa_create_params import QACreateParams as QACreateParams
 from .answer_extraction_response import AnswerExtractionResponse as AnswerExtractionResponse

isaacus/types/extractions/answer_extraction_response.py

@@ -10,6 +10,15 @@ __all__ = ["AnswerExtractionResponse", "Extraction", "ExtractionAnswer", "Usage"
 class ExtractionAnswer(BaseModel):
     """An answer extracted from a text."""
 
+    text: str
+    """The text 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`).
+    """
+
     end: int
     """
     The index of the character immediately after the last character of the answer in
@@ -22,28 +31,19 @@ class ExtractionAnswer(BaseModel):
     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):
     """The result of extracting answers from a text."""
 
-    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`).
     """
 
+    answers: List[ExtractionAnswer]
+    """Answers extracted from the text, ordered from highest to lowest score."""
+
     inextractability_score: float
     """
     A score between `0` and `1`, inclusive, representing the likelihood that an

isaacus/types/extractions/qa_create_params.py

@@ -7,10 +7,10 @@ from typing_extensions import Literal, Required, TypedDict
 
 from ..._types import SequenceNotStr
 
-__all__ = ["QaCreateParams", "ChunkingOptions"]
+__all__ = ["QACreateParams", "ChunkingOptions"]
 
 
-class QaCreateParams(TypedDict, total=False):
+class QACreateParams(TypedDict, total=False):
     model: Required[Literal["kanon-answer-extractor", "kanon-answer-extractor-mini"]]
     """
     The ID of the
@@ -35,9 +35,6 @@ class QaCreateParams(TypedDict, total=False):
     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
@@ -55,15 +52,18 @@ class QaCreateParams(TypedDict, total=False):
     If `null`, which is the default, all answers will be returned.
     """
 
+    chunking_options: Optional[ChunkingOptions]
+    """Options for how to split text into smaller chunks."""
+
 
 class ChunkingOptions(TypedDict, total=False):
     """Options for how to split text into smaller chunks."""
 
+    size: Optional[int]
+    """A whole number greater than or equal to 1."""
+
     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 or equal to 0."""
-
-    size: Optional[int]
-    """A whole number greater than or equal to 1."""

isaacus/types/id_number.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["IDNumber"]
+
+
+class IDNumber(BaseModel):
+    """An identification number mentioned in a document belonging to a legal person.
+
+    If an identification number was mentioned in the document but is not attributable to a legal person, it will not be extracted.
+    """
+
+    number: str
+    """The identification number."""
+
+    person: str
+    """The unique identifier of the person that this identification number belongs to."""
+
+    mentions: List[Span]
+    """
+    An array of one or more spans within the document's text where the
+    identification number is mentioned.
+    """

isaacus/types/location.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["Location"]
+
+
+class Location(BaseModel):
+    """A location identified within a document."""
+
+    id: str
+    """
+    The unique identifier of the location in the format `loc:{index}` where
+    `{index}` is a non-negative incrementing integer starting from zero.
+    """
+
+    name: Span
+    """A zero-based, half-open span into the Unicode code point space of input text.
+
+    All spans are globally laminar and well-nested similar to XML—it is impossible
+    for any two spans to partially overlap; they can only be disjoint, adjacent, or
+    wholly nested. Spans of the exact same type (e.g., segments) will never be
+    duplicated.
+
+    A span cannot be empty and will never start or end at whitespace.
+
+    Note that, when using programming languages other than Python (which uses
+    zero-based, half-open, Unicode code point-spaced string indexing), indices may
+    need to be translated accordingly (for example, JavaScript slices into UTF-16
+    code units instead of Unicode code points).
+    """
+
+    type: Literal["country", "state", "city", "address", "other"]
+    """
+    The type of the location, being one of `country`, `state`, `city`, `address`, or
+    `other`.
+    """
+
+    parent: Optional[str] = None
+    """
+    A unique identifier for a location in the format `loc:{index}` where `{index}`
+    is a non-negative incrementing integer starting from zero.
+    """
+
+    mentions: List[Span]
+    """
+    An array of one or more spans within the document's text where the location is
+    mentioned.
+    """

isaacus/types/person.py

@@ -0,0 +1,195 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["Person"]
+
+
+class Person(BaseModel):
+    """A legal person identified in a document."""
+
+    id: str
+    """
+    The unique identifier of the person in the format `per:{index}` where `{index}`
+    is a non-negative incrementing integer starting from zero.
+    """
+
+    name: Span
+    """A zero-based, half-open span into the Unicode code point space of input text.
+
+    All spans are globally laminar and well-nested similar to XML—it is impossible
+    for any two spans to partially overlap; they can only be disjoint, adjacent, or
+    wholly nested. Spans of the exact same type (e.g., segments) will never be
+    duplicated.
+
+    A span cannot be empty and will never start or end at whitespace.
+
+    Note that, when using programming languages other than Python (which uses
+    zero-based, half-open, Unicode code point-spaced string indexing), indices may
+    need to be translated accordingly (for example, JavaScript slices into UTF-16
+    code units instead of Unicode code points).
+    """
+
+    type: Literal["natural", "corporate", "politic"]
+    """
+    The legal entity type of the person, being one of `natural`, `corporate`, or
+    `politic`.
+
+    `natural` denotes a human being in their capacity as a natural legal person,
+    including when representing unincorporated entities such as partnerships and
+    trusts.
+
+    `corporate` denotes a body corporate such as a company, incorporated
+    partnership, or statutory corporation.
+
+    `politic` denotes a body politic such as a court, state, government, or
+    intergovernmental organization.
+    """
+
+    role: Literal[
+        "plaintiff",
+        "petitioner",
+        "applicant",
+        "appellant",
+        "appellee",
+        "claimant",
+        "complainant",
+        "defendant",
+        "respondent",
+        "prior_authority",
+        "prosecutor",
+        "defense_counsel",
+        "amicus",
+        "intervener",
+        "borrower",
+        "lender",
+        "guarantor",
+        "lessee",
+        "lessor",
+        "employer",
+        "employee",
+        "licensor",
+        "licensee",
+        "franchisor",
+        "franchisee",
+        "buyer",
+        "seller",
+        "contractor",
+        "shareholder",
+        "joint_venturer",
+        "investor",
+        "insurer",
+        "insured",
+        "enacting_authority",
+        "empowered_authority",
+        "settlor",
+        "trustee",
+        "beneficiary",
+        "debater",
+        "director",
+        "governing_jurisdiction",
+        "clerk",
+        "witness",
+        "other",
+        "non_party",
+    ]
+    """The role of the person in relation to the subject of the document.
+
+    The following roles are currently supported: | | | | ------------------------ |
+    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+    | | `plaintiff` | A party initiating the case that is the subject of the
+    document. | | `petitioner` | A party initiating the petition that is the subject
+    of the document. | | `applicant` | A party initiating the application that is
+    the subject of the document. | | `appellant` | A party appealing the decision
+    that is the subject of the document. | | `appellee` | A party responding to the
+    appeal that is the subject of the document if they are explicitly referred to as
+    an 'appellee'. | | `claimant` | A party making a claim in the case that is the
+    subject of the document. | | `complainant` | A party making a complaint in the
+    case that is the subject of the document. | | `defendant` | A party defending
+    against the case that is the subject of the document. | | `respondent` | A party
+    responding to the petition, appeal, or application that is the subject of the
+    document. | | `prior_authority` | An authority (e.g., judge, tribunal, court)
+    that made a prior decision in the case that is the subject of the document. Both
+    individual judges and courts should be annotated with this role where
+    applicable. This is not to be used for authorities cited as precedent, only for
+    those that made prior decisions in the same case. | | `prosecutor` | A lawyer
+    prosecuting the case that is the subject of the document. | | `defense_counsel`
+    | A lawyer defending the case that is the subject of the document. | | `amicus`
+    | A party filing an amicus curiae brief in the case that is the subject of the
+    document. | | `intervener` | A party attempting to or that has intervened in the
+    case that is the subject of the document. | | `borrower` | A party borrowing
+    money or other assets under the agreement that is the subject of the document,
+    including 'mortgagors' and 'debtors'. | | `lender` | A party lending money or
+    other assets under the agreement that is the subject of the document, including
+    'mortgagees' and 'creditors'. | | `guarantor` | A party guaranteeing obligations
+    under the agreement that is the subject of the document, including 'sureties'. |
+    | `lessee` | A party leasing goods or services under the agreement that is the
+    subject of the document, including 'tenants'. | | `lessor` | A party leasing
+    goods or services under the agreement that is the subject of the document,
+    including 'landlords'. | | `employer` | A party employing personnel under the
+    agreement that is the subject of the document. | | `employee` | A party employed
+    under the agreement that is the subject of the document. | | `licensor` | A
+    party licensing intellectual property or other rights under the agreement that
+    are the subject of the document. | | `licensee` | A party licensed to use
+    intellectual property or other rights under the agreement that are the subject
+    of the document. | | `franchisor` | A party granting a franchise under the
+    agreement that is the subject of the document. | | `franchisee` | A party
+    granted a franchise under the agreement that is the subject of the document. | |
+    `buyer` | A party purchasing goods or services under the agreement that is the
+    subject of the document, including 'purchasers', 'customers', and 'clients'. | |
+    `seller` | A party selling or providing goods or services under the agreement
+    that is the subject of the document, including 'Vendors', 'Suppliers', and
+    'Service Providers' (where such parties are actually providing goods or services
+    under the agreement). | | `contractor` | A party contracted to perform work or
+    services under the agreement that is the subject of the document, including
+    'consultants'. | | `shareholder` | A party holding shares or equity under the
+    agreement that is the subject of the document. | | `joint_venturer` | A party
+    participating in a joint venture under the agreement that is the subject of the
+    document. | | `investor` | A party investing money or assets under the agreement
+    that is the subject of the document. | | `insurer` | A party providing insurance
+    under the agreement that is the subject of the document. | | `insured` | A party
+    insured under the agreement that is the subject of the document. | | `settlor` |
+    A party establishing the trust that is the subject of the document. | |
+    `trustee` | A party managing the trust that is the subject of the document. | |
+    `beneficiary` | A party benefiting from the trust that is the subject of the
+    document. | | `enacting_authority` | An authority (e.g., legislature, regulator,
+    Minister/Secretary, President/Prime Minister, tribunal, court, judge) giving
+    legal effect to or authorizing the document. All relevant individuals and bodies
+    should be annotated with this role where applicable. | | `empowered_authority` |
+    An authority (e.g., government agency, regulator, Minister/Secretary,
+    President/Prime Minister, tribunal, court) empowered by the document to carry
+    out functions or duties. | | `debater` | A person participating in the debate
+    that is the subject of the document. | | `governing_jurisdiction` | The
+    jurisdiction whose laws govern the document. | | `director` | A director or
+    other officer of a corporate legal person mentioned in the document. | | `clerk`
+    | A clerk, notary, or other official certifying, witnessing, filing, recording,
+    registering, or otherwise administering the document. | | `witness` | A witness
+    witnessing the signing of the document, or whose testimony is part of the case
+    that is the subject of the document. | | `other` | A party to the case,
+    agreement, legislation, or regulation that is the subject of the document that
+    does not fit into any of the other roles. | | `non_party` | A legal person
+    mentioned in the document that is not a party to the case, agreement,
+    legislation, or regulation that is the subject of the document. |
+    """
+
+    parent: Optional[str] = None
+    """
+    A unique identifier for a legal person in the format `per:{index}` where
+    `{index}` is a non-negative incrementing integer starting from zero.
+    """
+
+    residence: Optional[str] = None
+    """
+    A unique identifier for a location in the format `loc:{index}` where `{index}`
+    is a non-negative incrementing integer starting from zero.
+    """
+
+    mentions: List[Span]
+    """
+    An array of one or more spans within the document's text where the person is
+    mentioned.
+    """

isaacus/types/phone_number.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["PhoneNumber"]
+
+
+class PhoneNumber(BaseModel):
+    """A valid phone number identified in a document belonging to a legal person.
+
+    If a phone number was mentioned in the document but is not valid, possible, or attributable to a legal person, it will not be extracted.
+    """
+
+    number: str
+    """
+    The normalized phone number in E.123 international notation conforming with
+    local conventions on the use of spaces and hyphens as separators.
+    """
+
+    person: str
+    """The unique identifier of the person that this phone number belongs to."""
+
+    mentions: List[Span]
+    """
+    An array of one or more spans within the document's text where the phone number
+    is mentioned.
+    """

isaacus/types/quote.py

@@ -0,0 +1,52 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["Quote"]
+
+
+class Quote(BaseModel):
+    """A quotation within a document."""
+
+    source_segment: Optional[str] = None
+    """
+    A unique identifier for a segment in the format `seg:{index}` where `{index}` is
+    a non-negative incrementing integer starting from zero.
+    """
+
+    source_document: Optional[str] = None
+    """
+    A unique identifier for an external document in the format `exd:{index}` where
+    `{index}` is a non-negative incrementing integer starting from zero.
+    """
+
+    source_person: Optional[str] = None
+    """
+    A unique identifier for a legal person in the format `per:{index}` where
+    `{index}` is a non-negative incrementing integer starting from zero.
+    """
+
+    amending: bool
+    """
+    Whether the quote is being used to amend or modify content, typically in other
+    documents.
+    """
+
+    span: Span
+    """A zero-based, half-open span into the Unicode code point space of input text.
+
+    All spans are globally laminar and well-nested similar to XML—it is impossible
+    for any two spans to partially overlap; they can only be disjoint, adjacent, or
+    wholly nested. Spans of the exact same type (e.g., segments) will never be
+    duplicated.
+
+    A span cannot be empty and will never start or end at whitespace.
+
+    Note that, when using programming languages other than Python (which uses
+    zero-based, half-open, Unicode code point-spaced string indexing), indices may
+    need to be translated accordingly (for example, JavaScript slices into UTF-16
+    code units instead of Unicode code points).
+    """

isaacus/types/reranking_create_params.py

@@ -34,8 +34,8 @@ class RerankingCreateParams(TypedDict, total=False):
     Each text must contain at least one non-whitespace character.
     """
 
-    chunking_options: Optional[ChunkingOptions]
-    """Options for how to split text into smaller chunks."""
+    top_n: Optional[int]
+    """A whole number greater than or equal to 1."""
 
     is_iql: bool
     """
@@ -62,18 +62,18 @@ class RerankingCreateParams(TypedDict, total=False):
     `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."""
+    chunking_options: Optional[ChunkingOptions]
+    """Options for how to split text into smaller chunks."""
 
 
 class ChunkingOptions(TypedDict, total=False):
     """Options for how to split text into smaller chunks."""
 
+    size: Optional[int]
+    """A whole number greater than or equal to 1."""
+
     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 or equal to 0."""
-
-    size: Optional[int]
-    """A whole number greater than or equal to 1."""