ಎಲ್ಲಾ extraction outputs ಅನ್ನು normalize ಮಾಡುವ ಏಕೀಕೃತ document model ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿ

ಪರಿಚಯ

Docling, Document AI ಮತ್ತು ಒಂದು ವಿಷನ್-ಲ್ಯಾಂಗ್ವೇಜ್ ಮಾಡೆಲ್‌ನಿಂದ ಡೇಟಾ ಎಳೆಯುವ ಇಂಜೆಸ್ಶನ್ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ನೀವು ನಿರ್ಮಿಸಿದಾಗ, ಪ್ರತಿ ಬ್ಯಾಕೆಂಡ್ ತನ್ನದೇ ಆದ ಆಕಾರದಲ್ಲಿ ಕಂಟೆಂಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ — ಇಲ್ಲಿ ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ಗಳು, ಅಲ್ಲಿ ಪುಟ ಶ್ರೇಣಿಗಳು, ಇನ್ನೊಂದೆಡೆ ಫ್ರೀಫಾರ್ಮ್ JSON — ಮತ್ತು ಪ್ರತಿ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಕನ್ಸ್ಯೂಮರ್ ಕೊನೆಗೆ if extractor == "docling": … ಮೇಲೆ ಬ್ರಾಂಚ್ ಮಾಡುತ್ತಾ ಹೋಗಿ, ಕೋಡ್‌ಬೇಸ್ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಹೆಸರುಗಳ ಸುತ್ತ ಪಳೆಯುಳಿಕೆಯಂತೆ ಗಟ್ಟಿಯಾಗಿಬಿಡುತ್ತದೆ. ಏಕೀಕೃತ ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡೆಲ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುವ ತಂಡಗಳು, ಹೊಸ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಬಂದಾಗಲೆಲ್ಲಾ ಚಂಕರ್‌ಗಳು, ಎಂಬೆಡರ್‌ಗಳು ಮತ್ತು ಸರ್ಚ್ ಇಂಡೆಕ್ಸರ್‌ಗಳನ್ನು ಮರುಬರೆಯುತ್ತಾ ಮುಂದಿನ ತ್ರೈಮಾಸಿಕವನ್ನು ಕಳೆಯುತ್ತವೆ. ಈ ಪಾಠದ ಕೊನೆಗೆ, ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್-ಯೂನಿಯನ್ ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್‌ಗಳು, ಪ್ರೊವೆನನ್ಸ್ ಮೆಟಾಡೇಟಾ ಮತ್ತು ಸ್ಥಿರವಾದ ಅಡಾಪ್ಟರ್ ಗಡಿಯೊಂದಿಗೆ ಒಂದು ಕ್ಯಾನೊನಿಕಲ್ ಡಾಕ್ಯುಮೆಂಟ್ ಸ್ಕೀಮಾವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ನೀವು ಸಮರ್ಥರಾಗುತ್ತೀರಿ, ಇದರಿಂದ ಯಾವ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಉತ್ಪಾದಿಸಿದರೂ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಸಿಸ್ಟಮ್‌ಗಳು ಒಂದೇ ಆಕಾರವನ್ನು ಬಳಸುತ್ತವೆ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• ಏಕೀಕೃತ ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡೆಲ್: ಪ್ರತಿ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಅಡಾಪ್ಟರ್ ಗುರಿಯಾಗಿಸಿಕೊಳ್ಳುವ ಒಂದೇ ಕ್ಯಾನೊನಿಕಲ್ ಸ್ಕೀಮಾ (ಇಲ್ಲಿ, UnifiedDocument), ಇದರಿಂದ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಚಂಕರ್‌ಗಳು, ಎಂಬೆಡರ್‌ಗಳು ಮತ್ತು ಇಂಡೆಕ್ಸರ್‌ಗಳು ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಹೆಸರಿನ ಮೇಲೆ ಬ್ರಾಂಚ್ ಮಾಡುವ ಬದಲು ಒಂದೇ ಆಕಾರವನ್ನು ಬಳಸುತ್ತವೆ.
• ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್: ಪ್ರತಿ ವೇರಿಯಂಟ್ ಒಂದು ಲಿಟರಲ್ block_type ಟ್ಯಾಗ್ ಹೊಂದಿರುವ (ಉದಾ. TableBlock ಮೇಲೆ Literal["table"]) ಪಾಲಿಮಾರ್ಫಿಕ್ ಕಂಟೆಂಟ್-ಬ್ಲಾಕ್ ಪ್ರಾತಿನಿಧ್ಯ; ಮಿಶ್ರ ಬ್ಲಾಕ್ ಪಟ್ಟಿಗಳನ್ನು ಅಸ್ಪಷ್ಟತೆಯಿಲ್ಲದೆ ಡೀಸೀರಿಯಲೈಸ್ ಮಾಡಲು Pydantic ಈ ಟ್ಯಾಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
• ಪ್ರೊವೆನನ್ಸ್ ಮೆಟಾಡೇಟಾ: ಯಾವ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಬ್ಲಾಕ್ ಅನ್ನು ಉತ್ಪಾದಿಸಿತು ಎಂಬುದರ ಪ್ರತಿ-ಬ್ಲಾಕ್ ಟ್ರ್ಯಾಕಿಂಗ್ (ಹೆಸರು, ಆವೃತ್ತಿ, ಪುಟ, ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್, ಕಾನ್ಫಿಡೆನ್ಸ್, quality_flags), ಇದನ್ನು ಬ್ಲಾಕ್‌ನ ಮೇಲೆಯೇ ಇರಿಸಲಾಗುತ್ತದೆ, ಇದರಿಂದ ಗುಣಮಟ್ಟ-ಅರಿವಿನ ಪ್ರೊಸೆಸಿಂಗ್ ಡೌನ್‌ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಫಿಲ್ಟರ್ ಮಾಡಬಹುದು ಅಥವಾ ಮರು-ಮಾರ್ಗಗೊಳಿಸಬಹುದು.
• ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಅಡಾಪ್ಟರ್: ಒಂದು ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್‌ನ ನೇಟಿವ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು UnifiedDocument ಆಗಿ ಭಾಷಾಂತರಿಸುವುದೇ ಏಕೈಕ ಕೆಲಸವಾಗಿರುವ ಪ್ರತ್ಯೇಕ ಕ್ಲಾಸ್ (ಉದಾ. DoclingAdapter); ಇದು ಇಂಜೆಸ್ಶನ್ ಅನ್ನು ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಆಯ್ಕೆಯಿಂದ ಬೇರ್ಪಡಿಸುವ ಸ್ಥಿರ ಗಡಿಯನ್ನು ರೂಪಿಸುತ್ತದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

ಈ ಪಾಠವು ಒಂದೇ ವಿನ್ಯಾಸವಾಗಿ ಒಟ್ಟಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಮೂರು ವಿಚಾರಗಳನ್ನು ಕಲಿಸುತ್ತದೆ.

ಒಂದು ಕ್ಯಾನೊನಿಕಲ್ ಸ್ಕೀಮಾ, ಅನೇಕ ಅಡಾಪ್ಟರ್‌ಗಳು. UnifiedDocument ಮಾಡೆಲ್ ಪ್ರತಿ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಕನ್ಸ್ಯೂಮರ್ ಅವಲಂಬಿಸಿರುವ ಒಪ್ಪಂದವಾಗಿದೆ; DoclingAdapter ಮತ್ತು ಭವಿಷ್ಯದ ಯಾವುದೇ DocumentAIAdapter / VLMAdapter ಗಳು ತಮ್ಮ ಬ್ಯಾಕೆಂಡ್‌ನ ನೇಟಿವ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಆ ಒಪ್ಪಂದಕ್ಕೆ ಮ್ಯಾಪ್ ಮಾಡಲು ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಹೊಸ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಸೇರಿಸುವುದರಿಂದ ಸ್ಕೀಮಾ ಅಥವಾ ಯಾವುದೇ ಕನ್ಸ್ಯೂಮರ್ ಎಂದಿಗೂ ಬದಲಾಗುವುದಿಲ್ಲ — ಅದು ಒಂದು ಅಡಾಪ್ಟರ್ ಕ್ಲಾಸ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ಬೇರೇನೂ ಇಲ್ಲ.

ಫ್ರೀ-ಫಾರ್ಮ್ JSON ಬದಲು ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳು. ನಿಜವಾದ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳು ಪ್ಯಾರಾಗ್ರಾಫ್‌ಗಳು, ಹೆಡಿಂಗ್‌ಗಳು, ಟೇಬಲ್‌ಗಳು, ಚಿತ್ರಗಳು ಮತ್ತು ಪಟ್ಟಿಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡುತ್ತವೆ. ಪ್ರತಿಯೊಂದನ್ನೂ ಲಿಟರಲ್ block_type ಟ್ಯಾಗ್ ಇರುವ Pydantic ಮಾಡೆಲ್ ಆಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡುವುದರಿಂದ list[ContentBlock | TableBlock] ಸರಿಯಾಗಿ ಡೀಸೀರಿಯಲೈಸ್ ಆಗುತ್ತದೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ TableBlock.headers ಅಥವಾ ContentBlock.level ನಂತಹ ವೇರಿಯಂಟ್-ನಿರ್ದಿಷ್ಟ ಫೀಲ್ಡ್‌ಗಳಿಗೆ ಟೈಪ್ ಮಾಡಿದ ಪ್ರವೇಶವನ್ನು ನಿಮಗೆ ನೀಡುತ್ತದೆ. ಫ್ರೀ-ಫಾರ್ಮ್ dict ಗಳು ಅದೇ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ ಆದರೆ ವ್ಯಾಲಿಡೇಶನ್ ಮತ್ತು IDE ಬೆಂಬಲವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ.

ಪ್ರೊವೆನನ್ಸ್ ಒಂದು ಪ್ರಥಮ-ದರ್ಜೆಯ ಫೀಲ್ಡ್, ಸೈಡ್‌ಕಾರ್ ಲಾಗ್ ಅಲ್ಲ. ಪ್ರತಿ ಬ್ಲಾಕ್ ತನ್ನದೇ ಆದ Provenance ಅನ್ನು (ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್, ಆವೃತ್ತಿ, ಪುಟ, bbox, ಕಾನ್ಫಿಡೆನ್ಸ್, quality_flags) ಹೊತ್ತೊಯ್ಯುವುದರಿಂದ, ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಕೋಡ್ ಬಾಹ್ಯ ಮೆಟಾಡೇಟಾ ಸ್ಟೋರ್‌ಗೆ ಮರಳಿ ಜಾಯಿನ್ ಮಾಡದೆಯೇ ಪ್ರತಿ-ಬ್ಲಾಕ್ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು — ಕಡಿಮೆ-ಕಾನ್ಫಿಡೆನ್ಸ್ VLM ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕೈಬಿಡುವುದು, ಫ್ಲ್ಯಾಗ್ ಮಾಡಿದ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಪರಿಶೀಲನೆಗಾಗಿ ಮರು-ಮಾರ್ಗಗೊಳಿಸುವುದು, RAG ಉತ್ತರದಲ್ಲಿ ಉಲ್ಲೇಖಗಳನ್ನು ಆರೋಪಿಸುವುದು. ಕೆಳಗಿನ ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ ಈ ಮೂರು ವಿಚಾರಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಸ್ಕೀಮಾದಲ್ಲಿ ಹೇಗೆ ನಿಖರವಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು DoclingAdapter ಅವುಗಳನ್ನು ಹೇಗೆ ಉತ್ಪಾದಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

Pydantic ಸ್ಕೀಮಾವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಡಾಕ್ಯುಮೆಂಟ್ ಕಂಟೆಂಟ್‌ನ ಪಾಲಿಮಾರ್ಫಿಕ್ ಸ್ವರೂಪವನ್ನು ನಿಭಾಯಿಸಲು ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್‌ಗಳೊಂದಿಗೆ Pydantic ಮಾಡೆಲ್‌ಗಳನ್ನು ಬಳಸಿ:

Code snippetpython
1from pydantic import BaseModel, Field
2from typing import Literal, Optional
3from datetime import datetime
4from enum import Enum
5
6class BlockType(str, Enum):
7    PARAGRAPH = "paragraph"
8    HEADING = "heading"
9    TABLE = "table"
10    FIGURE = "figure"
11    LIST_ITEM = "list_item"
12    CODE = "code"
13
14class Provenance(BaseModel):
15    extractor: str
16    extractor_version: str
17    page_number: Optional[int] = None
18    bbox: Optional[tuple[float, float, float, float]] = None
19    confidence: Optional[float] = None
20    quality_flags: list[str] = Field(default_factory=list)
21
22class TableCell(BaseModel):
23    text: str
24    row_span: int = 1
25    col_span: int = 1
26
27class TableBlock(BaseModel):
28    block_type: Literal["table"] = "table"
29    headers: list[str]
30    rows: list[list[TableCell]]
31    provenance: Provenance
32
33class ContentBlock(BaseModel):
34    block_type: BlockType
35    text: str
36    level: Optional[int] = None
37    children: list["ContentBlock"] = Field(default_factory=list)
38    provenance: Provenance
39
40class DocumentPage(BaseModel):
41    page_number: int
42    blocks: list[ContentBlock | TableBlock]
43
44class UnifiedDocument(BaseModel):
45    document_id: str
46    source_uri: str
47    schema_version: str = "1.0"
48    format: str
49    page_count: int
50    extraction_timestamp: datetime
51    pages: list[DocumentPage]
52    metadata: dict = Field(default_factory=dict)

• ಸಾಲುಗಳು 6-12: BlockType enum ನಿಮ್ಮ ಪೈಪ್‌ಲೈನ್ ನಿಭಾಯಿಸುವ ಎಲ್ಲಾ ಕಂಟೆಂಟ್ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಫ್ರೀ-ಫಾರ್ಮ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಬದಲು enum ಬಳಸುವುದರಿಂದ ವ್ಯಾಲಿಡೇಶನ್ ಸಮಯದಲ್ಲಿ ಟೈಪೋಗಳು ಸಿಕ್ಕಿಬೀಳುತ್ತವೆ ಮತ್ತು ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸರ್‌ಗಳಲ್ಲಿ ಸಮಗ್ರ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ.
• ಸಾಲುಗಳು 14-20: Provenance ಮಾಡೆಲ್ ಪ್ರತಿ ಬ್ಲಾಕ್ ಅನ್ನು ಯಾವ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಉತ್ಪಾದಿಸಿತು ಎಂಬುದನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. quality_flags ಪಟ್ಟಿಯು ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಸಮಯದಲ್ಲಿ ಪತ್ತೆಯಾದ ಸಮಸ್ಯೆಗಳನ್ನು ದಾಖಲಿಸುತ್ತದೆ — "low_confidence", "possible_hallucination", "truncated" — ಇದು ಡೌನ್‌ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿ ಗುಣಮಟ್ಟ-ಅರಿವಿನ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
• ಸಾಲುಗಳು 28-31: TableBlock block_type: Literal["table"] ಜೊತೆಗೆ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಇದರಿಂದ Pydantic ಮಿಶ್ರ ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್ ಪಟ್ಟಿಗಳನ್ನು ಸರಿಯಾಗಿ ಡೀಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದು. ಹೆಡರ್‌ಗಳು ಮತ್ತು ಸಾಲುಗಳು row_span ಮತ್ತು col_span ಮೂಲಕ ವಿಲೀನಗೊಂಡ ಸೆಲ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವ TableCell ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.
• ಸಾಲುಗಳು 33-37: ContentBlock children ಫೀಲ್ಡ್ ಮೂಲಕ ಪುನರಾವರ್ತಿತ ನೆಸ್ಟಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ; ಇದು ಸೆಕ್ಷನ್‌ಗಳು ಉಪವಿಭಾಗಗಳನ್ನು ಒಳಗೊಂಡು, ಅವು ಪ್ಯಾರಾಗ್ರಾಫ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ನಿಜವಾದ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳ ಶ್ರೇಣೀಕೃತ ರಚನೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.
• ಸಾಲುಗಳು 43-52: ಉನ್ನತ-ಮಟ್ಟದ UnifiedDocument ಡಾಕ್ಯುಮೆಂಟ್-ಮಟ್ಟದ ಮೆಟಾಡೇಟಾ, ಪ್ರತಿಯೊಂದರಲ್ಲೂ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಒಳಗೊಂಡ ಪುಟಗಳ ಪಟ್ಟಿ, ಮತ್ತು ವಿಕಸನಕ್ಕಾಗಿ ಒಂದು schema_version ಅನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ.

ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಅಡಾಪ್ಟರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು

ಪ್ರತಿ ಅಡಾಪ್ಟರ್ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್-ನಿರ್ದಿಷ್ಟ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಏಕೀಕೃತ ಮಾಡೆಲ್ ಆಗಿ ರೂಪಾಂತರಿಸುತ್ತದೆ:

Code snippetpython
1class DoclingAdapter:
2    EXTRACTOR_NAME = "docling"
3    EXTRACTOR_VERSION = "2.0"
4
5    def to_unified_document(
6        self, result, source_uri: str
7    ) -> UnifiedDocument:
8        doc = result.document
9        pages = []
10
11        current_page_blocks = []
12        current_page = 1
13
14        for item, level in doc.iterate_items():
15            page_num = item.prov[0].page_no if item.prov else current_page
16
17            if page_num != current_page and current_page_blocks:
18                pages.append(DocumentPage(
19                    page_number=current_page,
20                    blocks=current_page_blocks,
21                ))
22                current_page_blocks = []
23                current_page = page_num
24
25            provenance = Provenance(
26                extractor=self.EXTRACTOR_NAME,
27                extractor_version=self.EXTRACTOR_VERSION,
28                page_number=page_num,
29                bbox=item.prov[0].bbox.as_tuple() if item.prov else None,
30                confidence=None,
31            )
32
33            class_name = item.__class__.__name__
34            if class_name == "SectionHeaderItem":
35                block = ContentBlock(
36                    block_type=BlockType.HEADING,
37                    text=item.text,
38                    level=item.level,
39                    provenance=provenance,
40                )
41            elif class_name == "TableItem":
42                df = item.export_to_dataframe()
43                block = TableBlock(
44                    headers=list(df.columns),
45                    rows=[
46                        [TableCell(text=str(cell)) for cell in row]
47                        for _, row in df.iterrows()
48                    ],
49                    provenance=provenance,
50                )
51            else:
52                block = ContentBlock(
53                    block_type=BlockType.PARAGRAPH,
54                    text=item.text if hasattr(item, "text") else "",
55                    provenance=provenance,
56                )
57
58            current_page_blocks.append(block)
59
60        if current_page_blocks:
61            pages.append(DocumentPage(
62                page_number=current_page,
63                blocks=current_page_blocks,
64            ))
65
66        return UnifiedDocument(
67            document_id=self._generate_id(source_uri),
68            source_uri=source_uri,
69            format=str(result.input.format),
70            page_count=len(doc.pages) if hasattr(doc, "pages") else len(pages),
71            extraction_timestamp=datetime.utcnow(),
72            pages=pages,
73        )
74
75    def _generate_id(self, uri: str) -> str:
76        import hashlib
77        return hashlib.sha256(uri.encode()).hexdigest()[:16]

• ಸಾಲುಗಳು 1-3: ಪ್ರತಿ ಅಡಾಪ್ಟರ್ ತನ್ನ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಗುರುತನ್ನು ಕ್ಲಾಸ್ ಸ್ಥಿರಾಂಕಗಳಾಗಿ ಘೋಷಿಸುತ್ತದೆ, ಇದು ಈ ಅಡಾಪ್ಟರ್ ಪ್ರೊಸೆಸ್ ಮಾಡುವ ಎಲ್ಲಾ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳಲ್ಲಿ ಸ್ಥಿರವಾದ ಪ್ರೊವೆನನ್ಸ್ ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಸಾಲುಗಳು 14-23: ಕಂಟೆಂಟ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಪುಟ ಸಂಖ್ಯೆಯ ಪ್ರಕಾರ ಗುಂಪು ಮಾಡಿ. Docling ನ iterate_items() ಎಲಿಮೆಂಟ್‌ಗಳನ್ನು ಓದುವ ಕ್ರಮದಲ್ಲಿ ನೀಡುತ್ತದೆ, ಆದರೆ ಪುಟ ಪರಿವರ್ತನೆಗಳನ್ನು ಪ್ರೊವೆನನ್ಸ್ ಮೆಟಾಡೇಟಾದಿಂದ ಪತ್ತೆ ಮಾಡಬೇಕು.
• ಸಾಲುಗಳು 25-31: Docling ನ ಔಟ್‌ಪುಟ್‌ನಿಂದ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಹೆಸರು, ಆವೃತ್ತಿ, ಪುಟ ಸಂಖ್ಯೆ ಮತ್ತು ಬೌಂಡಿಂಗ್ ಬಾಕ್ಸ್‌ನೊಂದಿಗೆ ಪ್ರತಿ ಬ್ಲಾಕ್‌ಗೂ Provenance ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಿ.
• ಸಾಲುಗಳು 33-52: Docling ಎಲಿಮೆಂಟ್ ಪ್ರಕಾರಗಳನ್ನು ಏಕೀಕೃತ ಮಾಡೆಲ್ ಬ್ಲಾಕ್ ಪ್ರಕಾರಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಿ. SectionHeaderItem ತನ್ನ ಮಟ್ಟವನ್ನು ಉಳಿಸಿಕೊಂಡು ಹೆಡಿಂಗ್ ಆಗುತ್ತದೆ. TableItem ಅನ್ನು DataFrame ಗೆ ರಫ್ತು ಮಾಡಿ ನಂತರ ಸರಿಯಾದ TableCell ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕ್ಯಾನೊನಿಕಲ್ TableBlock ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಉಳಿದ ಎಲ್ಲಾ ಎಲಿಮೆಂಟ್‌ಗಳು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಪ್ಯಾರಾಗ್ರಾಫ್‌ಗಳಾಗುತ್ತವೆ.
• ಸಾಲುಗಳು 65-72: ಮೂಲ URI ನಿಂದ ಪಡೆದ ನಿರ್ಣಾಯಕ ID ಯೊಂದಿಗೆ ಅಂತಿಮ UnifiedDocument ಅನ್ನು ನಿರ್ಮಿಸಿ; ಇದು ಐಡೆಂಪೊಟೆಂಟ್ ಮರು-ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಅದೇ ಡಾಕ್ಯುಮೆಂಟ್ ID ಅನ್ನು ಉತ್ಪಾದಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಅಡಾಪ್ಟರ್ ಪ್ಯಾಟರ್ನ್ ನಿಮ್ಮ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಯಾವುದೇ ಒಂದು ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್ ಬ್ಯಾಕೆಂಡ್‌ನಿಂದ ಬೇರ್ಪಡಿಸುತ್ತದೆ. ಹೊಸ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಸೇರಿಸಲು ಯಾವುದೇ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಕನ್ಸ್ಯೂಮರ್ ಕೋಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸದೆ ಒಂದು ಹೊಸ ಅಡಾಪ್ಟರ್ ಕ್ಲಾಸ್ ಬರೆದರೆ ಸಾಕು.

ಶಿಸ್ತು ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ಈಗ ನೀವು ಅನುಷ್ಠಾನದ ಮೂಲಕ ಕೆಲಸ ಮಾಡಿರುವುದರಿಂದ, ಕೆಳಗಿನ ಅಭ್ಯಾಸಗಳು ಬಾಳಿಕೆ ಬರುವ ವಿಧಾನವನ್ನು ದುರ್ಬಲ ವಿಧಾನದಿಂದ ಬೇರ್ಪಡಿಸುತ್ತವೆ.

ಮಾಡಬೇಕಾದವು

1. ಪ್ರತಿ ಕಂಟೆಂಟ್-ಬ್ಲಾಕ್ ವೇರಿಯಂಟ್ ಅನ್ನು Literal["..."] block_type ನೊಂದಿಗೆ ಟ್ಯಾಗ್ ಮಾಡಿ, ಇದರಿಂದ Pydantic ಮಿಶ್ರ list[ContentBlock | TableBlock] ಕಂಟೆಂಟ್ ಅನ್ನು ಅಸ್ಪಷ್ಟತೆಯಿಲ್ಲದೆ ಡೀಸೀರಿಯಲೈಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಕನ್ಸ್ಯೂಮರ್‌ಗಳು ಟ್ಯಾಗ್ ಆಧಾರದ ಮೇಲೆ ಡಿಸ್ಪ್ಯಾಚ್ ಮಾಡಬಹುದು.
2. ಪ್ರತಿ ಬ್ಲಾಕ್‌ನಲ್ಲಿ Provenance ಅನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸಿ — ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಹೆಸರು, ಆವೃತ್ತಿ, ಪುಟ ಸಂಖ್ಯೆ, ಲಭ್ಯವಿದ್ದಲ್ಲಿ bbox, ಮತ್ತು quality_flags — ಇದರಿಂದ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಮರು-ರ‍್ಯಾಂಕಿಂಗ್, ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಉಲ್ಲೇಖ ಮಾರ್ಗಗಳು ಬಾಹ್ಯ ಮೆಟಾಡೇಟಾ ಸ್ಟೋರ್‌ಗೆ ಮರಳಿ ಜಾಯಿನ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ.
3. ನೀವು ಬ್ಲಾಕ್ ಪ್ರಕಾರವನ್ನು ಸೇರಿಸಿದಾಗ ಅಥವಾ ಫೀಲ್ಡ್‌ನ ಅರ್ಥವನ್ನು ಬದಲಾಯಿಸಿದಾಗಲೆಲ್ಲಾ UnifiedDocument ಮೇಲಿನ schema_version ಅನ್ನು ಹೆಚ್ಚಿಸಿ, ಮತ್ತು ಕನ್ಸ್ಯೂಮರ್‌ಗಳಿಗೆ ಆವೃತ್ತಿಯ ಮೇಲೆ ಬ್ರಾಂಚ್ ಮಾಡಲು ಕಲಿಸಿ (ಎಂದಿಗೂ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಮೇಲೆ ಅಲ್ಲ).

ಮಾಡಬಾರದವು

1. if extractor == "docling" ಬ್ರಾಂಚಿಂಗ್ ಅಡಾಪ್ಟರ್ ಗಡಿಯನ್ನು ದಾಟಿ ಸೋರಿಕೆಯಾಗಲು ಬಿಡಬೇಡಿ — ಒಮ್ಮೆ UnifiedDocument ಅಸ್ತಿತ್ವಕ್ಕೆ ಬಂದ ಮೇಲೆ, ಯಾವ ಬ್ಯಾಕೆಂಡ್ ಅದನ್ನು ಉತ್ಪಾದಿಸಿತು ಎಂಬುದು ಯಾವುದೇ ಚಂಕರ್, ಎಂಬೆಡರ್ ಅಥವಾ ಇಂಡೆಕ್ಸರ್‌ಗೆ ತಿಳಿದಿರಬಾರದು.
2. ಅಪರಿಚಿತ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಟರ್ ಎಲಿಮೆಂಟ್ ಪ್ರಕಾರಗಳನ್ನು ಫ್ರೀ-ಫಾರ್ಮ್ dict ಬ್ಲಾಬ್‌ಗಳಲ್ಲಿ ಹಾಕಬೇಡಿ; ಅವುಗಳನ್ನು ಹತ್ತಿರದ ಕ್ಯಾನೊನಿಕಲ್ BlockType ಗೆ ಮ್ಯಾಪ್ ಮಾಡಿ (ಡೀಫಾಲ್ಟ್ ಆಗಿ PARAGRAPH), ಇದರಿಂದ ಡಿಸ್ಕ್ರಿಮಿನೇಟೆಡ್ ಯೂನಿಯನ್ ಸಮಗ್ರವಾಗಿ ಉಳಿಯುತ್ತದೆ ಮತ್ತು ವ್ಯಾಲಿಡೇಶನ್ ಅರ್ಥಪೂರ್ಣವಾಗಿ ಉಳಿಯುತ್ತದೆ.
3. Provenance ಅನ್ನು ಐಚ್ಛಿಕಗೊಳಿಸಬೇಡಿ ಅಥವಾ ಸೈಡ್‌ಕಾರ್ ಲಾಗ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಡಿ — ನಾರ್ಮಲೈಸೇಶನ್ ನಂತರ ಗುಣಮಟ್ಟ-ಅರಿವಿನ ಪ್ರೊಸೆಸಿಂಗ್ ಕೆಲಸ ಮಾಡಲು ಬ್ಲಾಕ್-ಸ್ಥಳೀಯ ಪ್ರೊವೆನನ್ಸ್ ಇರುವುದೇ ಮುಖ್ಯ ಕಾರಣ.