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

isaacus/types/classifications/universal_classification_response.py

@@ -8,13 +8,6 @@ __all__ = ["UniversalClassificationResponse", "Classification", "ClassificationC
 
 
 class ClassificationChunk(BaseModel):
-    end: int
-    """
-    The index of the character immediately after the last character of the chunk in
-    the original text, beginning from `0` (such that, in Python, the chunk is
-    equivalent to `text[start:end]`).
-    """
-
     index: int
     """
     The original position of the chunk in the outputted list of chunks before
@@ -22,6 +15,19 @@ class ClassificationChunk(BaseModel):
     `1`).
     """
 
+    start: int
+    """
+    The index of the character in the original text where the chunk starts,
+    beginning from `0`.
+    """
+
+    end: int
+    """
+    The index of the character immediately after the last character of the chunk in
+    the original text, beginning from `0` (such that, in Python, the chunk is
+    equivalent to `text[start:end]`).
+    """
+
     score: float
     """
     The model's score of the likelihood that the query expressed about the chunk is
@@ -31,26 +37,11 @@ class ClassificationChunk(BaseModel):
     score less than `0.5` indicates that the chunk does not support the query.
     """
 
-    start: int
-    """
-    The index of the character in the original text where the chunk starts,
-    beginning from `0`.
-    """
-
     text: str
     """The text of the chunk."""
 
 
 class Classification(BaseModel):
-    chunks: Optional[List[ClassificationChunk]] = None
-    """
-    The text as broken into chunks by
-    [semchunk](https://github.com/isaacus-dev/semchunk), each chunk with its own
-    confidence score, ordered from highest to lowest score.
-
-    If no chunking occurred, this will be `null`.
-    """
-
     index: int
     """
     The index of the text in the input array of texts, starting from `0` (and,
@@ -66,6 +57,15 @@ class Classification(BaseModel):
     score less than `0.5` indicates that the text does not support the query.
     """
 
+    chunks: Optional[List[ClassificationChunk]] = None
+    """
+    The text as broken into chunks by
+    [semchunk](https://github.com/isaacus-dev/semchunk), each chunk with its own
+    confidence score, ordered from highest to lowest score.
+
+    If no chunking occurred, this will be `null`.
+    """
+
 
 class Usage(BaseModel):
     """Statistics about the usage of resources in the process of classifying the text."""

isaacus/types/classifications/universal_create_params.py

@@ -34,9 +34,6 @@ class UniversalCreateParams(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."""
-
     is_iql: bool
     """
     Whether the query should be interpreted as an
@@ -57,15 +54,18 @@ class UniversalCreateParams(TypedDict, total=False):
     `chunk_min` uses the lowest confidence score of all of the texts' chunks.
     """
 
+    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/crossreference.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .span import Span
+from .._models import BaseModel
+
+__all__ = ["Crossreference"]
+
+
+class Crossreference(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: 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/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 .span import Span
+from .._models import BaseModel
+
+__all__ = ["Date"]
+
+
+class Date(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[Span]
+    """
+    An array of one or more spans within the document's text where the date is
+    mentioned.
+    """

isaacus/types/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 .date import Date
+from .span import Span
+from .term import Term
+from .email import Email
+from .quote import Quote
+from .person import Person
+from .segment import Segment
+from .website import Website
+from .._models import BaseModel
+from .location import Location
+from .id_number import IDNumber
+from .phone_number import PhoneNumber
+from .crossreference import Crossreference
+from .external_document import ExternalDocument
+
+__all__ = ["Document"]
+
+
+class Document(BaseModel):
+    """The enriched document."""
+
+    title: Optional[Span] = 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[Span] = 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[Segment]
+    """
+    An array of segments within the document representing structurally distinct
+    portions of its content.
+    """
+
+    crossreferences: List[Crossreference]
+    """
+    An array of cross-references within the document pointing to a single segment or
+    a span of segments.
+    """
+
+    locations: List[Location]
+    """An array of locations identified in the document."""
+
+    persons: List[Person]
+    """An array of legal persons identified in the document."""
+
+    emails: List[Email]
+    """
+    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[Website]
+    """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[PhoneNumber]
+    """
+    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[IDNumber]
+    """
+    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[Term]
+    """An array of terms assigned definite meanings within the document."""
+
+    external_documents: List[ExternalDocument]
+    """An array of documents identified within the document."""
+
+    quotes: List[Quote]
+    """An array of quotations within the document."""
+
+    dates: List[Date]
+    """
+    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[Span]
+    """An array of spans within the document's text constituting headings."""
+
+    junk: List[Span]
+    """
+    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/email.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__ = ["Email"]
+
+
+class Email(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[Span]
+    """
+    An array of one or more spans within the document's text where the email address
+    is mentioned.
+    """

isaacus/types/embedding_create_params.py

@@ -25,8 +25,15 @@ class EmbeddingCreateParams(TypedDict, total=False):
     No more than 128 texts can be embedded in a single request.
     """
 
-    dimensions: Optional[int]
-    """A whole number greater than or equal to 1."""
+    task: Optional[Literal["retrieval/query", "retrieval/document"]]
+    """The task the embeddings will be used for.
+
+    `retrieval/query` is meant for queries and statements, and `retrieval/document`
+    is meant for anything to be retrieved using query embeddings.
+
+    If `null`, which is the default setting, embeddings will not be optimized for
+    any particular task.
+    """
 
     overflow_strategy: Optional[Literal["drop_end"]]
     """The strategy to employ when content exceeds the model's maximum input length.
@@ -38,12 +45,5 @@ class EmbeddingCreateParams(TypedDict, total=False):
     input length.
     """
 
-    task: Optional[Literal["retrieval/query", "retrieval/document"]]
-    """The task the embeddings will be used for.
-
-    `retrieval/query` is meant for queries and statements, and `retrieval/document`
-    is meant for anything to be retrieved using query embeddings.
-
-    If `null`, which is the default setting, embeddings will not be optimized for
-    any particular task.
-    """
+    dimensions: Optional[int]
+    """A whole number greater than or equal to 1."""

isaacus/types/embedding_response.py

@@ -8,15 +8,15 @@ __all__ = ["EmbeddingResponse", "Embedding", "Usage"]
 
 
 class Embedding(BaseModel):
-    embedding: List[float]
-    """The embedding of the content represented as an array of floating point numbers."""
-
     index: int
     """
     The position of the content in the input array of contents, starting from `0`
     (and, therefore, ending at the number of contents minus `1`).
     """
 
+    embedding: List[float]
+    """The embedding of the content represented as an array of floating point numbers."""
+
 
 class Usage(BaseModel):
     """Statistics about the usage of resources in the process of embedding the inputs."""