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

gllm_docproc/loader/image/image_loader.pyi

@@ -0,0 +1,54 @@
+from _typeshed import Incomplete
+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
+from gllm_docproc.model.element import Element as Element, IMAGE as IMAGE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+from gllm_docproc.model.media import Media as Media, MediaSourceType as MediaSourceType, MediaType as MediaType
+from typing import Any
+
+class ImageLoader(BaseLoader):
+    """A class for loading standalone image files.
+
+    This class defines the structure for loading standalone image files.
+    It supports all image formats by validating that the MIME type starts with 'image/'.
+
+    Methods:
+        load: Load an image file into a list of elements.
+        is_image_file: Check if a file is a valid image file based on the mime type.
+    """
+    logger: Incomplete
+    def __init__(self) -> None:
+        """Initialize the ImageLoader class."""
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load an image file into a list of elements.
+
+        This method loads an image file and creates Element objects with media metadata containing the image data.
+        For multi-page images, each page/frame is extracted as a separate element.
+
+        Args:
+            source (str): The path to the image file.
+            loaded_elements (list[dict[str, Any]] | None, optional): A list of elements that have already been loaded.
+            **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 elements containing the image data.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+            ValueError: If the file is not a valid image file.
+        """
+    def is_image_file(self, source: str) -> bool:
+        """Check if a file is a valid image file.
+
+        This method uses the `magic` library to check if a file is a valid image file
+        by examining its MIME type. Any file with a MIME type starting with 'image/' is considered valid.
+
+        Args:
+            source (str): The path to the file.
+
+        Returns:
+            bool: True if the file is a valid image file, False otherwise.
+        """

gllm_docproc/loader/json/__init__.pyi

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

gllm_docproc/loader/json/json_elements_loader.pyi

@@ -0,0 +1,35 @@
+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 gllm_docproc.model.element import Element as Element
+from typing import Any
+
+JSON: str
+
+class JSONElementsLoader(BaseLoader):
+    """JSON Elements Loader class.
+
+    This class provides a loader for extracting information from JSON files.
+    The JSON file must be in the format of list of dictionaries. where each dictionary
+    must be following the structure of Element class.
+
+    Methods:
+        load(source, element_metadata, **kwargs): Load and process a document.
+    """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process a document.
+
+        This method loads the JSON file and returns the list of elements. If file id is provided,
+        the file id will be added to the element metadata and the chunk id and chunk relation metadata
+        that contains file id as prefix will be updated.
+
+        Args:
+            source (str): The file path of the JSON file.
+            loaded_elements (Any, optional): The loaded elements. JSON Loader ignore this parameter.
+            **kwargs (Any): The keyword arguments.
+
+        Kwargs:
+            file_id (str, optional): The file id of for the elements. Defaults to None.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements.
+        """

gllm_docproc/loader/loader_utils.pyi

@@ -0,0 +1,43 @@
+from gllm_docproc.loader.exception import UnsupportedFileExtensionError as UnsupportedFileExtensionError
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+
+def validate_file_extension(expected_extensions: str | list[str], loader_name: str):
+    """Decorator to validate the file extension of the input file.
+
+    Args:
+        expected_extensions (str | list[str]): The expected file extension(s). Can be a single extension
+            as a string or a list of valid extensions. Extensions are case-insensitive.
+        loader_name (str): The name of the loader.
+
+    Returns:
+        Callable[[Callable[..., Any]], Callable[..., Any]]: A decorator that wraps the original
+            function to validate the file extension.
+
+    Raises:
+        UnsupportedFileExtensionError: If the file extension does not match the expected extension.
+    """
+def create_base_element_metadata(source: str, source_type: str) -> ElementMetadata:
+    """Create the base element metadata.
+
+    This function creates the base element metadata for the loaded element. Base element metadata
+    includes the source, source type, and loaded datetime.
+
+    Args:
+        source (str): The source of the element.
+        source_type (str): The source type.
+
+    Returns:
+        ElementMetadata: The base element metadata.
+    """
+def trim_table_empty_cells(table: list[list[str]]) -> list[list[str]]:
+    """Trim the empty cells in the table.
+
+    This function trims the empty cells in the table by removing the empty cells at the end of each
+    row. The function also ensures that all rows have the same number of columns.
+
+    Args:
+        table (List[List[str]]): A list of lists containing the table content.
+
+    Returns:
+        List[List[str]]: A list of lists containing the trimmed table content.
+    """

gllm_docproc/loader/pdf/__init__.pyi

@@ -0,0 +1,14 @@
+from .adobe_pdf_extract_loader import AdobePDFExtractLoader as AdobePDFExtractLoader
+from .azure_ai_document_intelligence_loader import AzureAIDocumentIntelligenceLoader as AzureAIDocumentIntelligenceLoader
+from .azure_ai_document_intelligence_raw_loader import AzureAIDocumentIntelligenceRawLoader as AzureAIDocumentIntelligenceRawLoader
+from .glair_vision_ocr_loader import GLAIRVisionOCRLoader as GLAIRVisionOCRLoader
+from .pdf_miner_loader import PDFMinerLoader as PDFMinerLoader
+from .pdf_miner_word_loader import PDFMinerWordLoader as PDFMinerWordLoader
+from .pdf_page_loader import PDFPageLoader as PDFPageLoader
+from .pdf_plumber_loader import PDFPlumberLoader as PDFPlumberLoader
+from .pymupdf_loader import PyMuPDFLoader as PyMuPDFLoader
+from .pymupdf_span_loader import PyMuPDFSpanLoader as PyMuPDFSpanLoader
+from .tabula_loader import TabulaLoader as TabulaLoader
+from .text_inject_pdf_plumber_loader import TextInjectPDFPlumberLoader as TextInjectPDFPlumberLoader
+
+__all__ = ['AdobePDFExtractLoader', 'AzureAIDocumentIntelligenceLoader', 'AzureAIDocumentIntelligenceRawLoader', 'GLAIRVisionOCRLoader', 'PDFMinerLoader', 'PDFPageLoader', 'PDFMinerWordLoader', 'PDFPlumberLoader', 'PyMuPDFLoader', 'PyMuPDFSpanLoader', 'TabulaLoader', 'TextInjectPDFPlumberLoader']

gllm_docproc/loader/pdf/adobe_pdf_extract_loader.pyi

@@ -0,0 +1,37 @@
+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 AdobePDFExtractLoader(BaseLoader):
+    """Adobe PDF Extract Loader class.
+
+    This class provides a loader for extracting information from PDF files using Adobe PDF Extract.
+    It implements the 'load' method to load PDF files and extract information.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Loads a PDF file and extracts information.
+    """
+    credentials: Incomplete
+    def __init__(self, client_id: str, client_secret: str) -> None:
+        """Initializes the Adobe PDF Extract Loader.
+
+        Args:
+            client_id (str): The client ID for the Adobe PDF Extract API.
+            client_secret (str): The client secret for the Adobe PDF Extract
+        """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> dict[str, Any]:
+        """Loads a PDF file and extracts information using Adobe PDF Extract.
+
+        This method loads a PDF file and extracts information from the file using Adobe PDF Extract.
+        The extracted information is returned as a dictionary. The extracted information includes text,
+        tables, and other elements from the PDF file.
+
+        Args:
+            source (str): The source PDF file to load and extract information from.
+            loaded_elements (Any): A list of loaded elements to be processed.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            dict[str, Any]: The extracted information as a dictionary
+        """

gllm_docproc/loader/pdf/azure_ai_document_intelligence_loader.pyi

@@ -0,0 +1,47 @@
+from _typeshed import Incomplete
+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.azure_ai_document_intelligence_raw_loader import AzureAIDocumentIntelligenceRawLoader as AzureAIDocumentIntelligenceRawLoader
+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, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, IMAGE as IMAGE, PDF as PDF
+from gllm_docproc.model.media import Media as Media, MediaSourceType as MediaSourceType, MediaType as MediaType
+from typing import Any
+
+class AzureAIDocumentIntelligenceLoader(BaseLoader):
+    """Azure AI Document Intelligence 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.
+    """
+    INCH_TO_POINT: int
+    endpoint: Incomplete
+    key: Incomplete
+    logger: Incomplete
+    def __init__(self, endpoint: str, key: str) -> None:
+        """Initializes the Azure AI Document Intelligence Loader 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: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process a document using the Azure AI Document Intelligence API.
+
+        Args:
+            source (str): The source of the document to be processed.
+            loaded_elements (list[dict[str, Any]], optional): A list of dictionaries containing loaded content and
+                metadata. Defaults to None.
+            **kwargs (Any): Additional keyword arguments for the loader.
+
+        Kwargs:
+            raw_output (dict[str, Any], optional): The raw output from the Azure AI Document Intelligence Raw Loader.
+            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/azure_ai_document_intelligence_raw_loader.pyi

@@ -0,0 +1,49 @@
+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 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_page_loader.pyi

@@ -0,0 +1,41 @@
+from _typeshed import Incomplete
+from gllm_docproc.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 convert_page_to_image_base64 as convert_page_to_image_base64, create_page_element as create_page_element
+from gllm_docproc.model.element import Element as Element, PAGE as PAGE
+from gllm_docproc.model.element_metadata import PDF as PDF
+from typing import Any
+
+class PDFPageLoader(BaseLoader):
+    """PDF Page Loader class.
+
+    This class defines the structure for loading PDF page level informations.
+    It implements the 'load' method to load the PDF file from a given file path.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PDF document.
+    """
+    dpi: Incomplete
+    def __init__(self, dpi: int = 150) -> None:
+        """Initialize the PDF Page Loader.
+
+        Args:
+            dpi (int, optional): Rendering resolution for each PDF page in Dots Per Inch (DPI).
+                Higher values produce higher-quality images but increase memory usage.
+                Defaults to 150.
+        """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and extract page level information from PDF document.
+
+        Args:
+            source (str): The file path to the PDF document.
+            loaded_elements (list[dict[str, Any]] | None, optional): Previously loaded elements from the same source.
+                If provided, new elements will be combined with existing ones. Defaults to None.
+            **kwargs (Any): Additional keyword arguments for PDF processing configuration.
+
+        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_plumber_loader.pyi

@@ -0,0 +1,35 @@
+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 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,55 @@
+from _typeshed import Incomplete
+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, convert_page_to_image_base64 as convert_page_to_image_base64, create_page_element as create_page_element, extract_image_element as extract_image_element, find_related_link as find_related_link
+from gllm_docproc.model.element import Element as Element, IMAGE as IMAGE, 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.
+    """
+    fallback_to_image: Incomplete
+    page_dpi: Incomplete
+    def __init__(self, fallback_to_image: bool = True, page_dpi: int = 150) -> None:
+        """Initialize the PyMuPDF Loader.
+
+        Args:
+            fallback_to_image (bool, optional): A boolean to determine if the loader should fall back to
+                rendering the entire page as a base64-encoded image when no text or embedded images are found.
+                Defaults to True.
+            page_dpi (int, optional): The DPI of the page image. Defaults to 150.
+        """
+    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,56 @@
+from _typeshed import Incomplete
+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, convert_page_to_image_base64 as convert_page_to_image_base64, create_page_element as create_page_element, extract_image_element as extract_image_element, find_related_link as find_related_link
+from gllm_docproc.model.element import Element as Element, IMAGE as IMAGE, 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.
+    """
+    fallback_to_image: Incomplete
+    page_dpi: Incomplete
+    def __init__(self, fallback_to_image: bool = True, page_dpi: int = 150) -> None:
+        """Initialize the PyMuPDF Loader.
+
+        Args:
+            fallback_to_image (bool, optional): A boolean to determine if the loader should fall back to
+                rendering the entire page as a base64-encoded image when no text or embedded images are found.
+                Defaults to True.
+            page_dpi (int, optional): The DPI of the page image. Defaults to 150.
+        """
+    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.
+        """