Paragraphs

Paragraphs#

Module for handling document paragraphs.

This module provides the Paragraph class, which represents a structured segment of text within a document. Paragraphs serve as containers for sentences and maintain the raw text content of the segment they represent.

The module supports validation to ensure data integrity and provides mechanisms to prevent inconsistencies during document analysis by restricting certain attribute modifications after initial assignment.

class contextgem.public.paragraphs.Paragraph(**data)[source]#

Bases: _Paragraph

Represents a paragraph of a document with its raw text content and constituent sentences.

Paragraphs are immutable text segments that can contain multiple sentences. Once sentences are assigned to a paragraph, they cannot be changed to maintain data integrity during analysis.

Variables:

  • raw_text (str) – The complete text content of the paragraph. This value is frozen after initialization.

  • sentences (list[Sentence]) – The individual sentences contained within the paragraph. Defaults to an empty list. Cannot be reassigned once populated.

  • additional_context (str | None) – Optional supplementary information about the paragraph, as a single-line string, e.g. its structural role, formatting, or position in the document (“Heading, level 2” or “Table: Fees, row 2, column 3”). It is passed to the LLM together with the paragraph text in the prompts that list paragraphs, i.e. when aspects are extracted, or when concepts are extracted with references. A decision model is sent it together with the paragraph text when aspects are extracted. Sentences segmented from the paragraph inherit it. Defaults to None.

Parameters:

  • custom_data (Annotated[dict[str, Any], BeforeValidator(func=~contextgem.internal.typings.validators._validate_is_json_dict, json_schema_input_type=PydanticUndefined)])

  • additional_context (Annotated[str, Strict(strict=True), StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=1, max_length=None, pattern=None, ascii_only=None)] | None)

  • raw_text (Annotated[str, Strict(strict=True), StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=1, max_length=None, pattern=None, ascii_only=None)])

  • sentences (list[_Sentence])

Note:

Normally, you do not need to construct paragraphs manually, as they are populated automatically from document’s raw_text attribute. Only use this constructor for advanced use cases, such as when you have a custom paragraph segmentation tool, or when you want to provide additional context for the paragraphs.

Example:
Paragraph definition#
from contextgem import Paragraph


# Create a paragraph with raw text content
contract_paragraph = Paragraph(
    raw_text=(
        "This agreement is effective as of January 1, 2025. "
        "All parties must comply with the terms outlined herein. "
        "Failure to adhere to these terms may result in termination of the agreement."
    )
)

# Create paragraphs with additional context, e.g. the structure or formatting
# details provided by your document conversion tool. The additional context is
# passed to the model together with the text of the paragraph.
heading_paragraph = Paragraph(
    raw_text="Term and Termination",
    additional_context="Heading, level 2",
)
table_cell_paragraph = Paragraph(
    raw_text="Net 30 days",
    additional_context="Table: Payment terms, row 2, column 3",
)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

clone()#

Creates and returns a deep copy of the current instance.

Return type:

typing.Self

Returns:

A deep copy of the current instance.

classmethod from_dict(obj_dict)#

Reconstructs an instance of the class from a dictionary representation.

This method deserializes a dictionary containing the object’s attributes and values into a new instance of the class. It handles complex nested structures like aspects, concepts, and extracted items, properly reconstructing each component.

A deserialized model or model group has no API credentials, as they are not included in the serialized data, i.e. they are to be set again.

Parameters:

obj_dict (dict[str, typing.Any]) – Dictionary containing the serialized object data.

Returns:

A new instance of the class with restored attributes.

Return type:

typing.Self

classmethod from_disk(file_path)#

Loads an instance of the class from a JSON file stored on disk.

This method reads the JSON content from the specified file path and deserializes it into an instance of the class using the from_json method.

Parameters:

file_path (str | pathlib.Path) – Path to the JSON file to load (must end with ‘.json’). Can be a string or a Path object.

Returns:

An instance of the class populated with the data from the file.

Return type:

typing.Self

Raises:

  • ValueError – If the file path doesn’t end with ‘.json’, or if the file does not hold valid serialized data, e.g. it is not a valid UTF-8 text (UnicodeDecodeError) or JSON (json.JSONDecodeError), or the data fails validation (pydantic’s ValidationError). These errors are subclasses of ValueError.

  • TypeError – If the serialized data is of another class.

  • OSError – If the file cannot be read, e.g. it does not exist. The error is the one raised by the file operation, e.g. FileNotFoundError or PermissionError.

classmethod from_json(json_string)#

Creates an instance of the class from a JSON string representation.

This method deserializes the provided JSON string into a dictionary and uses the from_dict method to construct the class instance. It validates that the class name in the serialized data matches the current class.

Parameters:

json_string (str) – JSON string containing the serialized object data.

Returns:

A new instance of the class with restored state.

Return type:

typing.Self

Raises:

  • json.JSONDecodeError – If the string is not a valid JSON. The error gives the position of what is invalid, and does not hold the string.

  • ValueError – If the JSON value is not an object with a class name, i.e. not serialized data.

  • TypeError – If the class name in the serialized data doesn’t match.

to_dict()#

Transforms the current object into a dictionary representation.

Converts the object to a dictionary that includes: - All public attributes - Special handling for specific public and private attributes

When a model or model group is serialized, its API credentials and usage/cost stats are removed.

Returns:

A dictionary representation of the current object with all necessary data for serialization

Return type:

dict[str, typing.Any]

to_disk(file_path)#

Saves the serialized instance to a JSON file at the specified path.

This method converts the instance to a dictionary representation using to_dict(), then writes it to disk as a formatted JSON file with UTF-8 encoding.

Parameters:

file_path (str | pathlib.Path) – Path where the JSON file should be saved (must end with ‘.json’). Can be a string or a Path object.

Return type:

None

Returns:

None

Raises:

  • ValueError – If the file path doesn’t end with ‘.json’.

  • OSError – If the file cannot be written, e.g. its directory does not exist. The error is the one raised by the file operation, e.g. FileNotFoundError or PermissionError.

to_json()#

Converts the object to its JSON string representation.

Serializes the object into a JSON-formatted string using the dictionary representation provided by the to_dict() method.

Returns:

A JSON string representation of the object.

Return type:

str

property unique_id: str#

Returns the ULID of the instance.

raw_text: Annotated[str, Strict(strict=True), StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=1, max_length=None, pattern=None, ascii_only=None)]#
sentences: list[_Sentence]#
additional_context: Annotated[str, Strict(strict=True), StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=1, max_length=None, pattern=None, ascii_only=None)] | None#
custom_data: Annotated[dict[str, Any], BeforeValidator(func=_validate_is_json_dict, json_schema_input_type=PydanticUndefined)]#