isaacus 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

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/ilgs_v1_crossreference.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+from .ilgs_v1_span import ILGSv1Span
+
+__all__ = ["ILGSv1Crossreference"]
+
+
+class ILGSv1Crossreference(BaseModel):
+    """A cross-reference within the document pointing to one or more segments."""
+
+    start: str
+    """
+    The unique identifier of the earliest segment in the span of segments being
+    cross-referenced with ties broken in favor of the least-nested (i.e., largest)
+    segment. If the cross-reference points to a single segment, `start` and `end`
+    will be identical.
+    """
+
+    end: str
+    """
+    The unique identifier of the latest segment in the span of segments being
+    cross-referenced with ties broken in favor of the least-nested (i.e., largest)
+    segment. If the cross-reference points to a single segment, `start` and `end`
+    will be identical.
+    """
+
+    span: ILGSv1Span
+    """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/ilgs_v1_date.py

@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .ilgs_v1_span import ILGSv1Span
+
+__all__ = ["ILGSv1Date"]
+
+
+class ILGSv1Date(BaseModel):
+    """
+    A date identified in a document belonging to one of the following types: `creation`, `signature`, `effective`, `expiry`, `delivery`, `renewal`, `payment`, `birth`, or `death`.
+
+    Only Gregorian dates between the years 1000 and 9999 (inclusive) fitting into one of the supported date types are extractable.
+    """
+
+    value: str
+    """The date in ISO 8601 format (YYYY-MM-DD)."""
+
+    type: Literal["creation", "signature", "effective", "expiry", "delivery", "renewal", "payment", "birth", "death"]
+    """
+    The type of the date, being one of `creation`, `signature`, `effective`,
+    `expiry`, `delivery`, `renewal`, `payment`, `birth`, or `death`. If a date is
+    mentioned in a document that does not fit into a supported type, it will not be
+    extracted.
+
+    `creation` denotes the date the document was created. There may only be one
+    `creation` date per document.
+
+    `signature` denotes the date the document was signed.
+
+    `effective` denotes the date when the document or a part thereof comes into
+    effect (e.g., commencement or enactment dates).
+
+    `expiry` denotes the date when the document or a part thereof is no longer in
+    effect.
+
+    `delivery` denotes the date when goods or services are to be delivered under the
+    document.
+
+    `renewal` denotes the date when one or more of the document's terms are to be
+    renewed.
+
+    `payment` denotes the date when payment is to be made under the document.
+
+    `birth` denotes the birth date of a natural person or establishment (e.g.,
+    incorporation) date of a non-natural legal person identified in the document.
+    There can only be one `birth` date linked to a single person and all `birth`
+    dates must be linked to a person. A person's `birth` date will never be after
+    their `death` date.
+
+    `death` denotes the death date of a natural person or dissolution date of a
+    non-natural legal person identified in the document. There can only be one
+    `death` date linked to a single person and all `death` dates must be linked to a
+    person. A person's `death` date will never be before their `birth` date.
+    """
+
+    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.
+    """
+
+    mentions: List[ILGSv1Span]
+    """
+    An array of one or more spans within the document's text where the date is
+    mentioned.
+    """

isaacus/types/ilgs_v1_document.py

@@ -0,0 +1,172 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .ilgs_v1_date import ILGSv1Date
+from .ilgs_v1_span import ILGSv1Span
+from .ilgs_v1_term import ILGSv1Term
+from .ilgs_v1_email import ILGSv1Email
+from .ilgs_v1_quote import ILGSv1Quote
+from .ilgs_v1_person import ILGSv1Person
+from .ilgs_v1_segment import ILGSv1Segment
+from .ilgs_v1_website import ILGSv1Website
+from .ilgs_v1_location import ILGSv1Location
+from .ilgs_v1_id_number import ILGSv1IDNumber
+from .ilgs_v1_phone_number import ILGSv1PhoneNumber
+from .ilgs_v1_crossreference import ILGSv1Crossreference
+from .ilgs_v1_external_document import ILGSv1ExternalDocument
+
+__all__ = ["ILGSv1Document"]
+
+
+class ILGSv1Document(BaseModel):
+    """The enriched document."""
+
+    title: Optional[ILGSv1Span] = None
+    """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).
+    """
+
+    subtitle: Optional[ILGSv1Span] = None
+    """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 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.
+    """
+
+    segments: List[ILGSv1Segment]
+    """
+    An array of segments within the document representing structurally distinct
+    portions of its content.
+    """
+
+    crossreferences: List[ILGSv1Crossreference]
+    """
+    An array of cross-references within the document pointing to a single segment or
+    a span of segments.
+    """
+
+    locations: List[ILGSv1Location]
+    """An array of locations identified in the document."""
+
+    persons: List[ILGSv1Person]
+    """An array of legal persons identified in the document."""
+
+    emails: List[ILGSv1Email]
+    """
+    An array of email addresses identified in the document belonging to legal
+    persons.
+
+    Email addresses mentioned in the document that are not attributable to legal
+    persons will not be extracted.
+    """
+
+    websites: List[ILGSv1Website]
+    """An array of websites identified in the document belonging to legal persons.
+
+    Websites mentioned in the document that are not attributable to legal persons
+    will not be extracted.
+    """
+
+    phone_numbers: List[ILGSv1PhoneNumber]
+    """
+    An array of valid phone numbers identified in the document belonging to legal
+    persons.
+
+    Phone numbers mentioned in the document that are not valid, possible, or
+    attributable to legal persons will not be extracted.
+    """
+
+    id_numbers: List[ILGSv1IDNumber]
+    """
+    An array of identification numbers identified in the document belonging to legal
+    persons.
+
+    Identification numbers mentioned in the document that are not attributable to
+    legal persons will not be extracted.
+    """
+
+    terms: List[ILGSv1Term]
+    """An array of terms assigned definite meanings within the document."""
+
+    external_documents: List[ILGSv1ExternalDocument]
+    """An array of documents identified within the document."""
+
+    quotes: List[ILGSv1Quote]
+    """An array of quotations within the document."""
+
+    dates: List[ILGSv1Date]
+    """
+    An array of dates identified in the document belonging to one of the following
+    types: `creation`, `signature`, `effective`, `expiry`, `delivery`, `renewal`,
+    `payment`, `birth`, or `death`.
+
+    Only Gregorian dates between the years 1000 and 9999 (inclusive) fitting into
+    one of the supported date types are extractable.
+    """
+
+    headings: List[ILGSv1Span]
+    """An array of spans within the document's text constituting headings."""
+
+    junk: List[ILGSv1Span]
+    """
+    An array of spans within the document's text constituting non-operative,
+    non-substantive 'junk' content such as headers, footers, page numbers, and OCR
+    artifacts.
+    """
+
+    version: Literal["ilgs@1"]

isaacus/types/ilgs_v1_email.py

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

isaacus/types/ilgs_v1_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 .._models import BaseModel
+from .ilgs_v1_span import ILGSv1Span
+
+__all__ = ["ILGSv1ExternalDocument"]
+
+
+class ILGSv1ExternalDocument(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: ILGSv1Span
+    """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[ILGSv1Span]
+    """
+    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[ILGSv1Span]
+    """
+    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/ilgs_v1_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 .._models import BaseModel
+from .ilgs_v1_span import ILGSv1Span
+
+__all__ = ["ILGSv1IDNumber"]
+
+
+class ILGSv1IDNumber(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[ILGSv1Span]
+    """
+    An array of one or more spans within the document's text where the
+    identification number is mentioned.
+    """

isaacus/types/ilgs_v1_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 .._models import BaseModel
+from .ilgs_v1_span import ILGSv1Span
+
+__all__ = ["ILGSv1Location"]
+
+
+class ILGSv1Location(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: ILGSv1Span
+    """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[ILGSv1Span]
+    """
+    An array of one or more spans within the document's text where the location is
+    mentioned.
+    """