Skip to content

ontocast.onto.content_unit

Attributes

Classes

ContentUnit

Bases: SourceUnit

A processing unit that extends source data with mutable output fields.

Source code in ontocast/onto/content_unit.py 
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
class ContentUnit(SourceUnit):
    """A processing unit that extends source data with mutable output fields."""

    graph: RDFGraph = Field(
        description="RDF triples representing facts rendered from this source unit in turtle format "
        "as a string in compact form: use prefixes for namespaces, do NOT add comments",
        default_factory=RDFGraph,
    )

    _graph_absolute: RDFGraph | None = PrivateAttr(default=None)

    processed: bool = Field(default=False, description="Was this unit processed?")
    generated_at: datetime | None = Field(
        default=None, description="generated timestamp"
    )

    @property
    def graph_absolute(self):
        if self._graph_absolute is None:
            self._graph_absolute = self.graph.copy()
            self._graph_absolute.remap_namespaces(self.iri, self.iri_absolute)
        return self._graph_absolute

    @property
    def generated_at_iso(self) -> str:
        """Get generated timestamp in ISO format.

        Returns:
            str: Timestamp in ISO format.
        """
        if self.generated_at is None:
            self.generated_at = datetime.now(timezone.utc)
        return self.generated_at.isoformat()

    def sanitize(self):
        if not isinstance(self.graph, RDFGraph):
            normalized_graph = RDFGraph()
            for triple in self.graph:
                normalized_graph.add(triple)
            for prefix, namespace in self.graph.namespaces():
                normalized_graph.bind(prefix, namespace)
            self.graph = normalized_graph
        self.graph = self.graph.unbind_chunk_namespaces()
        self.graph.sanitize_prefixes_namespaces()

Attributes

generated_at = Field(default=None, description='generated timestamp') class-attribute instance-attribute
generated_at_iso property

Get generated timestamp in ISO format.

Returns:

Name Type Description
str str

Timestamp in ISO format.
graph = Field(description='RDF triples representing facts rendered from this source unit in turtle format as a string in compact form: use prefixes for namespaces, do NOT add comments', default_factory=RDFGraph) class-attribute instance-attribute
graph_absolute property
processed = Field(default=False, description='Was this unit processed?') class-attribute instance-attribute

Methods:

sanitize()
Source code in ontocast/onto/content_unit.py 
179
180
181
182
183
184
185
186
187
188
def sanitize(self):
    if not isinstance(self.graph, RDFGraph):
        normalized_graph = RDFGraph()
        for triple in self.graph:
            normalized_graph.add(triple)
        for prefix, namespace in self.graph.namespaces():
            normalized_graph.bind(prefix, namespace)
        self.graph = normalized_graph
    self.graph = self.graph.unbind_chunk_namespaces()
    self.graph.sanitize_prefixes_namespaces()

OutputType

Bases: StrEnum

Source code in ontocast/onto/content_unit.py 
21
22
23
class OutputType(StrEnum):
    FACTS = "facts"
    ONTOLOGIES = "ontologies"

Attributes

FACTS = 'facts' class-attribute instance-attribute
ONTOLOGIES = 'ontologies' class-attribute instance-attribute

SourceUnit

Bases: BaseModel

Immutable source unit identity and input text.

Attributes:

Name Type Description
text str

Source text content for this unit.
index int

Position of this unit in the source document.
hid str

A stable hash id derived from text.
doc_iri URIRef

IRI of parent document.
type OutputType

Type of content unit (facts or ontology).
Source code in ontocast/onto/content_unit.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
class SourceUnit(BaseModel):
    """Immutable source unit identity and input text.

    Attributes:
        text: Source text content for this unit.
        index: Position of this unit in the source document.
        hid: A stable hash id derived from text.
        doc_iri: IRI of parent document.
        type: Type of content unit (facts or ontology).
    """

    model_config = ConfigDict(arbitrary_types_allowed=True)

    text: str = Field(description="Source text content for this unit")
    index: int = Field(description="Position of this unit in the source document")
    doc_iri: URIRef = Field(description="IRI of parent doc")
    type: OutputType = Field(
        default=OutputType.FACTS, description="Type of content unit"
    )
    section_label: str | None = Field(
        default=None,
        description="Section label assigned during chunk prepare (e.g. results, methods)",
    )
    section_label_source: SectionLabelSource | None = Field(
        default=None,
        description=(
            "Which tier of the section-classification cascade decided "
            "section_label (heading pattern/keyword, span overlap, content "
            "density, LLM, forward fill)."
        ),
    )
    section_label_confidence: float = Field(
        default=0.0,
        description="Confidence in section_label in [0, 1]; 0 when unlabeled.",
    )
    headings: list[str] | None = Field(
        default=None,
        description="Docling heading breadcrumb for this chunk (tagging hint).",
    )
    doc_item_refs: list[str] = Field(
        default_factory=list,
        description="Docling doc_item self_refs covered by this chunk (tagging hint).",
    )
    summary: str | None = Field(
        default=None,
        description="LLM-compressed summary of this chunk used for extraction prompts",
    )
    is_citation_metadata: bool = Field(
        default=False,
        description=(
            "Unit detected as bibliography/reference-list content; facts "
            "rendering extracts citation metadata only, never domain facts."
        ),
    )
    is_non_content: bool = Field(
        default=False,
        description=(
            "Unit detected as front/back matter with no domain facts (author "
            "block, notes, ORCID, data availability, licence) and kept under "
            "CHUNK_NON_CONTENT_MODE=extract; checks that presume domain prose "
            "should stand down on it."
        ),
    )
    _hid: str = PrivateAttr(default="")

    @field_validator("doc_iri", mode="before")
    @classmethod
    def _coerce_doc_iri(cls, value: URIRef | str) -> URIRef:
        if isinstance(value, URIRef):
            return value
        return URIRef(value)

    @computed_field(return_type=str)
    @property
    def hid(self) -> str:
        """Stable hash id generated from source text."""
        rendered_hid = render_text_hash(self.text)
        if self._hid != rendered_hid:
            self._hid = rendered_hid
        return self._hid

    @property
    def iri(self) -> str:
        """Get the base IRI for this unit.

        Returns:
            str: The base unit IRI.
        """
        return DEFAULT_IRI

    @property
    def iri_absolute(self) -> str:
        """Get the absolute IRI for this unit.

        Returns:
            str: The unit IRI.
        """
        return f"{self.doc_iri}/{self.hid}"

    @property
    def namespace(self) -> str:
        """Get the namespace for this unit.

        Returns:
            str: The unit namespace.
        """
        return normalize_namespace_iri(self.iri, context="facts")

    def __len__(self):
        return len(self.text)

    @property
    def extraction_text(self) -> str:
        """Text fed to extraction and critique LLM prompts."""
        if self.summary:
            return self.summary
        return self.text

Attributes

doc_iri = Field(description='IRI of parent doc') class-attribute instance-attribute
doc_item_refs = Field(default_factory=list, description='Docling doc_item self_refs covered by this chunk (tagging hint).') class-attribute instance-attribute
extraction_text property

Text fed to extraction and critique LLM prompts.

headings = Field(default=None, description='Docling heading breadcrumb for this chunk (tagging hint).') class-attribute instance-attribute
hid property

Stable hash id generated from source text.

index = Field(description='Position of this unit in the source document') class-attribute instance-attribute
iri property

Get the base IRI for this unit.

Returns:

Name Type Description
str str

The base unit IRI.
iri_absolute property

Get the absolute IRI for this unit.

Returns:

Name Type Description
str str

The unit IRI.
is_citation_metadata = Field(default=False, description='Unit detected as bibliography/reference-list content; facts rendering extracts citation metadata only, never domain facts.') class-attribute instance-attribute
is_non_content = Field(default=False, description='Unit detected as front/back matter with no domain facts (author block, notes, ORCID, data availability, licence) and kept under CHUNK_NON_CONTENT_MODE=extract; checks that presume domain prose should stand down on it.') class-attribute instance-attribute
model_config = ConfigDict(arbitrary_types_allowed=True) class-attribute instance-attribute
namespace property

Get the namespace for this unit.

Returns:

Name Type Description
str str

The unit namespace.
section_label = Field(default=None, description='Section label assigned during chunk prepare (e.g. results, methods)') class-attribute instance-attribute
section_label_confidence = Field(default=0.0, description='Confidence in section_label in [0, 1]; 0 when unlabeled.') class-attribute instance-attribute
section_label_source = Field(default=None, description='Which tier of the section-classification cascade decided section_label (heading pattern/keyword, span overlap, content density, LLM, forward fill).') class-attribute instance-attribute
summary = Field(default=None, description='LLM-compressed summary of this chunk used for extraction prompts') class-attribute instance-attribute
text = Field(description='Source text content for this unit') class-attribute instance-attribute
type = Field(default=OutputType.FACTS, description='Type of content unit') class-attribute instance-attribute

Methods:

__len__()
Source code in ontocast/onto/content_unit.py 
134
135
def __len__(self):
    return len(self.text)

Functions: