gllm-docproc-binary 0.1.8__cp311-cp311-win_amd64.whl

gllm_docproc/loader/pdf/azure_ai_document_intelligence_raw_loader.pyi

@@ -0,0 +1,50 @@
+from _typeshed import Incomplete
+from azure.ai.documentintelligence.models import AnalyzeResult as AnalyzeResult
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import validate_file_extension as validate_file_extension
+from typing import Any
+
+class AzureAIDocumentIntelligenceRawLoader(BaseLoader):
+    """Azure AI Document Intelligence Raw Loader class.
+
+    This class provides a loader for extracting text, tables, and images from PDF files
+    using the Azure AI Document Intelligence API. It implements the 'load' method to handle document
+    loading from a given source.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load and process a document.
+    """
+    endpoint: Incomplete
+    key: Incomplete
+    def __init__(self, endpoint: str, key: str) -> None:
+        """Initializes the AzureAILoader class.
+
+        Args:
+            endpoint (str): The endpoint for the Azure AI Document Intelligence API.
+            key (str): The key for the Azure AI Document Intelligence API.
+        """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> dict[str, Any]:
+        '''Load and process a document using the Azure AI Document Intelligence API.
+
+        This method sends a request to the Azure AI Document Intelligence API to extract information
+        from a PDF file. It returns the extracted information in a dictionary format, without any
+        additional processing.
+
+        Kwargs:
+            model_id (str, optional): The model used for document analysis. Azure AI Document Intelligence API
+                provides several prebuilt models for document analysis, check for available models at:
+                https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/concept-model-overview?
+                view=doc-intel-4.0.0#model-analysis-features
+                Defaults to "prebuilt-layout".
+            features (list[str], optional): The add-on capabilities. Document Intelligence supports more sophisticated
+                analysis capabilities. These optional features can be enabled and disabled depending on the scenario
+                of the document extraction. Check for available add on capabilities at:
+                https://learn.microsoft.com/en-us/python/api/overview/azure/ai-documentintelligence-readme?
+                view=azure-python-preview#add-on-capabilities
+                Defaults to an empty list.
+
+        Args:
+            source (str): The source of the document to be processed.
+            loaded_elements (Any): A list of loaded elements to be processed.
+            **kwargs (Any): Additional keyword arguments.
+        '''

gllm_docproc/loader/pdf/glair_vision_ocr_loader.pyi

@@ -0,0 +1,38 @@
+from _typeshed import Incomplete
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import validate_file_extension as validate_file_extension
+from typing import Any
+
+class GLAIRVisionOCRLoader(BaseLoader):
+    """GLAIR Vision OCR Loader class.
+
+    This class provides a loader for extracting text and table from PDF file using the GLAIR Vision OCR API.
+    It implements the 'load' method to handle document loading from a given source.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load and process a document.
+    """
+    username: Incomplete
+    password: Incomplete
+    api_key: Incomplete
+    def __init__(self, username: str, password: str, api_key: str) -> None:
+        """Initializes the GLAIRVisionOCRLoader class.
+
+        Args:
+            username (str): The username for the GLAIR Vision OCR API.
+            password (str): The password for the GLAIR Vision OCR API.
+            api_key (str): The API key for the GLAIR Vision OCR API.
+        """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> dict[str, Any]:
+        """Load and process a document using the GLAIR Vision OCR API.
+
+        This method loads a PDF document from a given source and extracts text and table using the GLAIR Vision OCR API.
+
+        Args:
+            source (str): The source of the document to be processed.
+            loaded_elements (Any): The loaded elements from previous loaders.
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            dict: The OCR response from the GLAIR Vision OCR API.
+        """

gllm_docproc/loader/pdf/pdf_loader_utils.pyi

@@ -0,0 +1,59 @@
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from typing import Any
+
+def merge_loaded_elements_by_coordinates(loaded_elements: list[Element], existing_loaded_elements: list[Element], **kwargs: Any) -> list[Element]:
+    """Merge the loaded elements by coordinates.
+
+    This function merges elements from 'loaded_elements' into 'existing_loaded_elements' based on
+    coordinates. The 'loaded_elements' inside the 'existing_loaded_elements' (eg. table) will be
+    duplicated information and will not be included in the merged list.
+
+    Args:
+        loaded_elements (List[Element]): A list of Elements containing loaded element content.
+        existing_loaded_elements (List[Element]): A list of existing Elements.
+        kwargs (Any): Additional keyword arguments for merging the loaded elements.
+
+    Kwargs:
+        is_object_inside_box_threshold (float, optional): The threshold of the intersection area to the area
+            of the object. Defaults to 1.
+        merge_element_with_duplicates (Callable[[Element, List[Element]], Element], optional): The function
+            to merge the new element with the duplicate elements. Defaults to _merge_element_with_duplicates.
+
+    Returns:
+        list[Element]: A list of Element containing merged loaded element content.
+    """
+def bbox_to_coordinates(bbox: list[float]) -> list[int]:
+    """Convert the bounding box to coordinates.
+
+    This method converts the bounding box to coordinates.
+
+    Args:
+        bbox (list[float]): The bounding box.
+
+    Returns:
+        list[int]: The coordinates.
+    """
+def is_object_inside_box(object_coordinates: list[int], box_coordinates: list[int], threshold: float = 1) -> bool:
+    """Validate is object coordinates position inside the box.
+
+    Args:
+        object_coordinates (list[int]): The coordinates position of the object.
+        box_coordinates (list[int]): The coordinates position of the box.
+        threshold (float): The threshold of the intersection area to the area of the object.
+
+    Returns:
+        bool: True if the object coordinates position inside the box.
+    """
+def calculate_object_intersection_over_box_area(object_coordinates: list[int], box_coordinates: list[int]) -> float:
+    """Calculate the ratio of the intersection area of an object to the area of a bounding box.
+
+    This function computes the area of intersection between the given object coordinates and box coordinates,
+    and then calculates the ratio of this intersection area to the area of the object.
+
+    Args:
+        object_coordinates (list[int]): The coordinates of the object in the format [left, right, bottom, top].
+        box_coordinates (list[int]): The coordinates of the bounding box in the format [left, right, bottom, top].
+
+    Returns:
+        float: The ratio of the intersection area to the area of the object. Returns 0 if there is no intersection.
+    """

gllm_docproc/loader/pdf/pdf_miner_loader.pyi

@@ -0,0 +1,38 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class PDFMinerLoader(BaseLoader):
+    """A class for loading and processing PDF document using PDFMiner.
+
+    This class defines the structure for loading and processing PDF document to retrieve required values
+    (text and metadata). It implements the 'load' method to handle PDF loading from a given file path.
+
+    PDFMinerLoader is used to extract the TEXT and metadata from the PDF document.
+    Text loader have to be the first loader in the pipeline. This prioritization is because subsequent
+    loaders like the Table Loader may contain overlapping information with the Text Loader.
+    Therefore, these subsequent loaders rely on the output from the Text Loader. They merge the
+    loaded elements and filter out any duplicates by using the information provided by the Text Loader.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process a PDF document specified by the file path and name (source).
+
+        This method defines the process of loading a PDF document using its file path.
+        It uses PDFMiner to extract element text and element metadata from the PDF document.
+
+        Args:
+            source (str): The path to the PDF document file.
+            loaded_elements (list[dict[str, Any]]): A list of dictionaries containing loaded content and metadata.
+            **kwargs (Any): Additional keyword arguments for the loader.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: A list of dictionaries containing loaded content and metadata.
+        """

gllm_docproc/loader/pdf/pdf_miner_word_loader.pyi

@@ -0,0 +1,33 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class PDFMinerWordLoader(BaseLoader):
+    """PDFMinerWordLoader is used to extract the TEXT from the PDF document.
+
+    This class defines the structure for loading PDF documents using PDFMiner per word.
+    It implements the 'load' method to extract PDF information from a given file path.
+
+    PDFMinerWordLoader is used to extract the TEXT from the PDF document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a PDF document.
+
+        This method loads a PDF document from a given file path.
+
+        Args:
+            source (str): The file path of the PDF document.
+            loaded_elements (list[dict[str, Any]]): The loaded elements.
+            **kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements.
+        """

gllm_docproc/loader/pdf/pdf_plumber_loader.pyi

@@ -0,0 +1,38 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, trim_table_empty_cells as trim_table_empty_cells, validate_file_extension as validate_file_extension
+from gllm_docproc.loader.pdf.pdf_loader_utils import bbox_to_coordinates as bbox_to_coordinates, merge_loaded_elements_by_coordinates as merge_loaded_elements_by_coordinates
+from gllm_docproc.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from pdfplumber._typing import T_obj as T_obj
+from pdfplumber.page import Page as Page
+from pdfplumber.table import Table as Table
+from typing import Any
+
+class PDFPlumberLoader(BaseLoader):
+    """A class for loading and processing PDF document using PDFPlumberLoader.
+
+    This class defines the structure for loading and processing PDF document to retrieve required values
+    (table and metadata). It implements the 'load' method to handle PDF loading from a given file path.
+
+    PDFPlumberLoader is used to extract the TABLE and metadata from the PDF document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process PDF document specified by the file path and name (source).
+
+        This method defines the process of loading and extracting table information from
+        PDF document using PDF Plumber library using its file path and name.
+
+        Args:
+            source (str): The path to the PDF document file.
+            loaded_elements (list[dict[str, Any]]): A list of dictionaries containing loaded content and metadata.
+            **kwargs (Any): Additional keyword arguments for the loader.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: A list of dictionaries containing loaded content and metadata.
+        """

gllm_docproc/loader/pdf/pymupdf_loader.pyi

@@ -0,0 +1,43 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.loader.pdf.pymupdf_utils import bbox_to_coordinates as bbox_to_coordinates, extract_image_element as extract_image_element, find_related_link as find_related_link
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class PyMuPDFLoader(BaseLoader):
+    """A class for loading and processing PDF document using PyMuPDF.
+
+    This class defines the structure for loading and processing PDF document to retrieve required values
+    (text and image in base64 format). It implements the 'load' method to handle PDF loading from a given file path.
+
+    PyMuPDFLoader is used to extract the TEXT and IMAGE in base64 format from the PDF document.
+    Text loader have to be the first loader in the pipeline. This prioritization is because subsequent
+    loaders like the Table Loader may contain overlapping information with the Text Loader.
+    Therefore, these subsequent loaders rely on the output from the Text Loader. They merge the
+    loaded elements and filter out any duplicates by using the information provided by the Text Loader.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process a PDF document specified by the file path and name (source).
+
+        This method defines the process of loading a PDF document using its file path.
+        It uses PyMuPDF to extract element text and element image from the PDF document.
+
+        Args:
+            source (str): The path to the PDF document file.
+            loaded_elements (list[dict[str, Any]]): A list of dictionaries containing loaded content and metadata.
+            **kwargs (Any): Additional keyword arguments for the loader.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+            hyperlink_as_markdown (bool, optional): A boolean to determine if the hyperlink should be in
+                markdown format. Defaults to True.
+            sort_elements (Callable, optional): A callable function to sort the elements in every page.
+                Defaults to None. Means no sorting will be done.
+
+        Returns:
+            list[dict[str, Any]]: A list of dictionaries containing loaded content and metadata.
+        """

gllm_docproc/loader/pdf/pymupdf_span_loader.pyi

@@ -0,0 +1,44 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.loader.pdf.pymupdf_utils import bbox_to_coordinates as bbox_to_coordinates, extract_image_element as extract_image_element, find_related_link as find_related_link
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class PyMuPDFSpanLoader(BaseLoader):
+    """PyMuPDFSpanLoader class to extract text per span from a PDF file using PyMuPDF.
+
+    This class defines the structure for extracting text per span from a PDF file using PyMuPDF.
+    It implements the load method to extract information from a PDF file from a given source.
+
+    PyMuPDFLoader is used to extract the TEXT, HYPERLINK, and IMAGE in base64 format from the PDF document.
+    Text loader have to be the first loader in the pipeline. This prioritization is because subsequent
+    loaders like the Table Loader may contain overlapping information with the Text Loader.
+    Therefore, these subsequent loaders rely on the output from the Text Loader. They merge the
+    loaded elements and filter out any duplicates by using the information provided by the Text Loader.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a PDF file using PyMuPDF and extract text span.
+
+        This method loads a PDF file using PyMuPDF and extracts text per span. It will return
+        a list of loaded elements. Span is a segment of text within a document, representing a
+        continuous sequence of characters with the same formatting (such as font, size, and color).
+
+        Args:
+            source (str): The path to the PDF file.
+            loaded_elements (list[dict[str, Any]] | None): A list of loaded elements. Defaults to None.
+            **kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+            hyperlink_as_markdown (bool, optional): A boolean to determine if the hyperlink should be in
+                markdown format. Defaults to True.
+            sort_elements (Callable, optional): A callable function to sort the elements in every page.
+                Defaults to None. Means no sorting will be done.
+
+        Returns:
+            list[dict[str, Any]]: A list of loaded elements.
+        """

gllm_docproc/loader/pdf/pymupdf_utils.pyi

@@ -0,0 +1,34 @@
+from gllm_docproc.loader.pdf.pdf_loader_utils import bbox_to_coordinates as bbox_to_coordinates
+from gllm_docproc.model.element import Element as Element, IMAGE as IMAGE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+from typing import Any
+
+def extract_image_element(image_instance: dict[str, Any], page_idx: int, element_metadata: ElementMetadata, page_layout_width: int, page_layout_height: int) -> Element:
+    """Extract value (image in base64 format and other metadata) from image element.
+
+    This method defines the process of extracting Image value in base64 format from image element.
+
+    Args:
+        image_instance (dict): The image instance.
+        page_idx (int): The number of the page index.
+        element_metadata (ElementMetadata): The element metadata.
+        page_layout_width (int): The width of the page layout.
+        page_layout_height (int): The height of the page layout.
+
+    Returns:
+        Element: An Element object containing image in base64 format and metadata.
+    """
+def find_related_link(text_rect: list[float], links: list[dict[str, Any]]) -> dict[str, Any] | None:
+    """Find the related link for a text rectangle.
+
+    This method finds the related link for a text rectangle. It will return the link if the text
+    rectangle intersects with the link rectangle.
+
+    Args:
+        text_rect (list[float]): The text rectangle.
+        links (list[dict[str, Any]]): A list of links.
+
+    Returns:
+        dict[str, Any] | None: The related link if the text rectangle intersects with the link rectangle
+            or None if the text rectangle does not intersect with the link rectangle.
+    """

gllm_docproc/loader/pdf/tabula_loader.pyi

@@ -0,0 +1,32 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, trim_table_empty_cells as trim_table_empty_cells, validate_file_extension as validate_file_extension
+from gllm_docproc.loader.pdf.pdf_loader_utils import merge_loaded_elements_by_coordinates as merge_loaded_elements_by_coordinates
+from gllm_docproc.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class TabulaLoader(BaseLoader):
+    """A class for loading PDF and extracting Table from PDF using Tabula.
+
+    This class defines the structure for loading PDF and extracting Table from PDF using Tabula.
+    It implements the 'load' method to handle the loading and extraction process.
+
+    TabulaLoader is used to extract the TABLE and metadata from the PDF document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load the PDF file and extract Table from PDF using Tabula.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load the PDF file and extract Table from PDF using Tabula.
+
+        Args:
+            source (str): The file path of the PDF document.
+            loaded_elements (list[dict[str, Any]]): A list of loaded elements from the PDF document.
+            **kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: A list of dictionaries containing loaded content and metadata.
+        """

gllm_docproc/loader/pdf/text_inject_pdf_plumber_loader.pyi

@@ -0,0 +1,37 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, trim_table_empty_cells as trim_table_empty_cells, validate_file_extension as validate_file_extension
+from gllm_docproc.loader.pdf.pdf_loader_utils import merge_loaded_elements_by_coordinates as merge_loaded_elements_by_coordinates
+from gllm_docproc.loader.pdf.pdf_miner_word_loader import PDFMinerWordLoader as PDFMinerWordLoader
+from gllm_docproc.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PDF as PDF
+from typing import Any
+
+class TextInjectPDFPlumberLoader(BaseLoader):
+    """A class for loading PDF documents using PDFPlumber by injecting text into tables.
+
+    This class defines the structure for loading PDF documents using PDFPlumber by injecting text into tables.
+    It implements the 'load' method to handle PDF loading from a given file path.
+
+    TextInjectPDFPlumberLoader is used to extract the TABLE from the PDF document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a PDF document.
+
+        This method loads a PDF document from a given file path.
+
+        Args:
+            source (str): The file path of the PDF document.
+            loaded_elements (list[dict[str, Any]]): The loaded elements.
+            kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+            font_size_threshold (int, optional): The font size threshold. Defaults to None.
+                When None, the font size threshold will be most frequent font size multiplied by 2.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements.
+        """

gllm_docproc/loader/pipeline_loader.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from gllm_datastore.cache_data_store.cache_data_store import BaseCacheDataStore as BaseCacheDataStore
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from typing import Any
+
+class PipelineLoader:
+    """A pipeline loader for loading documents.
+
+    This class serves as the pipeline loader for loading document. It defines the structure for
+    loading document with several loaders using pipeline.
+
+    Methods:
+        add_loader(loader): Add loader to the pipeline loader.
+        load(source, **kwargs): Load the document from the given source.
+    """
+    loaders: list[BaseLoader]
+    cache_data_store: Incomplete
+    logger: Incomplete
+    def __init__(self, cache_data_store: BaseCacheDataStore | None = None) -> None:
+        """Initialize the PipelineLoader.
+
+        Args:
+            cache_data_store (BaseCacheDataStore, optional): The cache data store to be used.
+                Defaults to None.
+        """
+    def add_loader(self, loader: BaseLoader):
+        """Add loader to the pipeline loader.
+
+        This method defines the process of adding loader to the pipeline loader.
+
+        Args:
+            loader (BaseLoader): The loader to be added.
+        """
+    def load(self, source: str, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load the document from the given file path.
+
+        This method defines the process of loading the document using loaders.
+
+        Args:
+            source (str): Might be file path, URL, the content itself.
+            **kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            ttl (int, optional): The TTL of the cache. Defaults to None.
+
+        Returns:
+            List[dict[str, Any]]: A list of dictionaries containing loaded content and metadata.
+        """

gllm_docproc/loader/txt/__init__.pyi

@@ -0,0 +1,3 @@
+from .txt_loader import TXTLoader as TXTLoader
+
+__all__ = ['TXTLoader']

gllm_docproc/loader/txt/txt_loader.pyi

@@ -0,0 +1,26 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import TXT as TXT
+from typing import Any
+
+class TXTLoader(BaseLoader):
+    """A class for loading text files (.txt) into a list of elements.
+
+    Methods:
+        load: Load a text file into a list of elements.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a text file into a list of elements.
+
+        Args:
+            source (str): The path to the text file.
+            loaded_elements (list[dict[str, Any]]): The list of elements that have already been loaded.
+            **kwargs: Additional keyword arguments.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: A list of elements.
+        """

gllm_docproc/loader/xlsx/__init__.pyi

@@ -0,0 +1,3 @@
+from .openpyxl_loader import OpenpyxlLoader as OpenpyxlLoader
+
+__all__ = ['OpenpyxlLoader']

gllm_docproc/loader/xlsx/openpyxl_loader.pyi

@@ -0,0 +1,37 @@
+from gllm_docproc.loader.base_loader import BaseLoader as BaseLoader
+from gllm_docproc.loader.loader_utils import create_base_element_metadata as create_base_element_metadata, validate_file_extension as validate_file_extension
+from gllm_docproc.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, XLSX as XLSX
+from openpyxl.cell.cell import MergedCell as MergedCell
+from typing import Any
+
+class OpenpyxlLoader(BaseLoader):
+    """A class used to load and process XLSX documents using the openpyxl library.
+
+    This class inherits from the BaseLoader class and overrides its methods to provide
+    functionality for loading XLSX documents. It provides methods to extract tables from
+    the document, determine whether a row is a header based on its style attributes, and
+    split a table into headers and body based on the row styles and header threshold.
+
+    Methods:
+        load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any)
+            -> list[dict[str, Any]]: Load a XLSX document.
+    """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a XLSX document.
+
+        This method loads a XLSX document and extracts the table elements from each sheet.
+        The method takes the source file path as input and returns a list of Element objects
+        representing the tables in the document.
+
+        Args:
+            source (str): The path to the XLSX document to load.
+            loaded_elements (list[dict[str, Any]]): The loaded elements from previous loaders.
+            **kwargs (Any): Additional keyword arguments to pass to the loader.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements from the XLSX document.
+        """

gllm_docproc/model/__init__.pyi

@@ -0,0 +1,4 @@
+from .element import Element as Element
+from .element_metadata import ElementMetadata as ElementMetadata
+
+__all__ = ['Element', 'ElementMetadata']

gllm_docproc/model/element.pyi

@@ -0,0 +1,37 @@
+from _typeshed import Incomplete
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+from pydantic import BaseModel
+from typing import Any
+
+UNCATEGORIZED_TEXT: str
+HEADER: str
+TITLE: str
+HEADING: Incomplete
+PARAGRAPH: str
+TABLE: str
+AUDIO: str
+IMAGE: str
+VIDEO: str
+FOOTER: str
+FOOTNOTE: str
+MAX_HEADING_LEVEL: int
+
+class Element(BaseModel):
+    """An Element model.
+
+    This class serves as the Element model for storing element text, structure, and metadata.
+
+    Attributes:
+        text (str): The element text.
+        structure (str): The element structure.
+        metadata (dict): The element metadata.
+    """
+    text: str
+    structure: str
+    metadata: ElementMetadata
+    @staticmethod
+    def to_list_dict(elements: list['Element']) -> list[dict[str, Any]]:
+        """Convert a list of Element objects to a list of dictionaries."""
+    @staticmethod
+    def from_list_dict(elements: list[dict[str, Any]]) -> list['Element']:
+        """Convert a list of dictionaries to a list of Element objects."""