gllm-docproc-binary 0.7.26__cp311-cp311-macosx_13_0_arm64.whl

gllm_docproc/dpo_router/base_dpo_router.pyi

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseDPORouter(ABC):
+    """Base class for routing in document processing."""
+    @abstractmethod
+    def route(self, *args: Any, **kwargs: Any) -> Any:
+        """Routes the input into different processing pipelines based on certain criteria.
+
+        Args:
+            *args (Any): Variable length argument list for routing parameters.
+            **kwargs (Any): Arbitrary keyword arguments for additional routing configuration.
+
+        Returns:
+            Any: The result of the routing process.
+        """

gllm_docproc/dpo_router/loader_router.pyi

@@ -0,0 +1,52 @@
+from _typeshed import Incomplete
+from gllm_docproc.dpo_router.base_dpo_router import BaseDPORouter as BaseDPORouter
+from gllm_docproc.loader.csv.pandas_loader import CSV_VARIANTS as CSV_VARIANTS
+from gllm_docproc.loader.image import ImageLoader as ImageLoader
+from gllm_docproc.loader.json.json_elements_loader import JSON as JSON
+from gllm_docproc.loader.txt import TXTLoader as TXTLoader
+from gllm_docproc.loader.video.video_loader_utils import is_supported_video_file as is_supported_video_file
+from gllm_docproc.model import Element as Element, LoaderType as LoaderType
+from gllm_docproc.model.element_metadata import DOCX as DOCX, HTML as HTML, PDF as PDF, PPTX as PPTX, XLSX as XLSX
+from typing import Any
+
+class LoaderRouter(BaseDPORouter):
+    """Loader Router class.
+
+    This router determines the appropriate loader type based on the input source.
+    Returns a dict with the loader type information.
+    """
+    logger: Incomplete
+    txt_loader: Incomplete
+    image_loader: Incomplete
+    def __init__(self) -> None:
+        """Initialize the LoaderRouter.
+
+        This method initializes the LoaderRouter.
+        """
+    def route(self, source: str, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        """Route the input source to the appropriate loader type.
+
+        This method determines the appropriate loader type based on the input source.
+        It checks if the source is a file or a YouTube URL.
+        1. If it is a file, it checks the file extension or content to determine the loader type.
+        2. If it is a YouTube URL, it returns the audio loader type.
+        3. If it is not a file or a YouTube URL, it returns the uncategorized loader type.
+
+        Args:
+            source (str): The input source, either a file path or a YouTube URL.
+            *args (Any): Additional arguments.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the loader type information.
+                Example: {LoaderType.KEY: LoaderType.PDF_LOADER}
+        """
+    def is_html_from_json(self, source: str) -> bool:
+        """Check if the source file contains valid HTML metadata.
+
+        Args:
+            source (str): The file path to check.
+
+        Returns:
+            bool: True if the file is a valid HTML metadata file, False otherwise.
+        """

gllm_docproc/dpo_router/parser_router.pyi

@@ -0,0 +1,42 @@
+from _typeshed import Incomplete
+from gllm_docproc.dpo_router.base_dpo_router import BaseDPORouter as BaseDPORouter
+from gllm_docproc.model.element import Element as Element
+from gllm_docproc.model.element_metadata import AUDIO as AUDIO, CSV as CSV, DOCX as DOCX, HTML as HTML, IMAGE as IMAGE, PDF as PDF, PPTX as PPTX, TXT as TXT, VIDEO as VIDEO, XLSX as XLSX
+from gllm_docproc.model.parser_type import ParserType as ParserType
+from typing import Any
+
+class ParserRouter(BaseDPORouter):
+    """Parser Router class.
+
+    This router determines the appropriate parser type based on the input source.
+    Returns a dict with the parser type information.
+    """
+    logger: Incomplete
+    source_type_to_parser_type: Incomplete
+    def __init__(self) -> None:
+        """Initialize the ParserRouter.
+
+        This method initializes the ParserRouter.
+        """
+    def route(self, source: str | list[dict[str, Any]], *args, **kwargs) -> dict[str, Any]:
+        """Determine the parser type from the input source.
+
+        The input source can be:
+        - A string path to a JSON file containing loaded elements.
+        - A list of loaded element dictionaries (in memory).
+
+        This method reads the input, extracts the `source_type` from the first element’s metadata,
+        and returns the appropriate parser type. If loading fails or metadata is missing,
+        the parser type will be set as UNCATEGORIZED.
+
+        Args:
+            source (str | list[dict[str, Any]]): The input source, which can be either:
+                - str: path to a JSON file containing loaded elements.
+                - list[dict[str, Any]]: loaded elements.
+            *args (Any): Additional arguments.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the parser type information.
+                Example: {ParserType.KEY: ParserType.PDF_PARSER}
+        """

gllm_docproc/housekeeping/__init__.pyi

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

gllm_docproc/housekeeping/base_housekeeping.pyi

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+class BaseHouseKeeping(ABC):
+    """Base class for document converter."""
+    @abstractmethod
+    def housekeeping(self, folder_path: str) -> None:
+        """Placeholder method for performing housekeeping tasks on a specified folder.
+
+        Args:
+            folder_path (str): The path to the folder to perform housekeeping on.
+
+        Returns:
+            None
+        """

gllm_docproc/indexer/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_docproc.indexer.base_indexer import BaseIndexer as BaseIndexer
+
+__all__ = ['BaseIndexer']

gllm_docproc/indexer/base_indexer.pyi

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseIndexer(ABC):
+    """Base class for document converter."""
+    @abstractmethod
+    def index(self, elements: Any, **kwargs: Any) -> Any:
+        """Index data from a source file into Elasticsearch.
+
+        Args:
+            elements (Any): The information to be indexed. Ideally formatted as List[Dict] and
+                each Dict following the structure of model 'Element'.
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            Any: The response from the indexing process.
+        """
+    @abstractmethod
+    def delete(self, **kwargs: Any) -> Any:
+        """Delete document from a vector DB.
+
+        The arguments are not defined yet, it depends on the implementation.
+        Some vector database will require: db_url, index_name, document_id.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            Any: The response from the deletion process.
+        """

gllm_docproc/indexer/graph/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_docproc.indexer.graph.light_rag_graph_rag_indexer import LightRAGGraphRAGIndexer as LightRAGGraphRAGIndexer
+from gllm_docproc.indexer.graph.llama_index_graph_rag_indexer import LlamaIndexGraphRAGIndexer as LlamaIndexGraphRAGIndexer
+
+__all__ = ['LlamaIndexGraphRAGIndexer', 'LightRAGGraphRAGIndexer']

gllm_docproc/indexer/graph/graph_rag_indexer.pyi

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+from gllm_docproc.indexer import BaseIndexer as BaseIndexer
+
+class BaseGraphRAGIndexer(BaseIndexer, ABC):
+    """Abstract base class for Graph RAG Indexer.
+
+    This class defines the interface for a Graph RAG Indexer.
+    """
+    @abstractmethod
+    def resolve_entities(self) -> None:
+        """Resolve entities in the graph."""

gllm_docproc/indexer/graph/light_rag_graph_rag_indexer.pyi

@@ -0,0 +1,97 @@
+from gllm_datastore.graph_data_store.light_rag_data_store import BaseLightRAGDataStore
+from gllm_docproc.indexer.graph.graph_rag_indexer import BaseGraphRAGIndexer as BaseGraphRAGIndexer
+from gllm_docproc.model.element import Element as Element
+from typing import Any
+
+class LightRAGGraphRAGIndexer(BaseGraphRAGIndexer):
+    '''Indexer abstract base class for LightRAG-based graph RAG.
+
+    How to run LightRAG with PostgreSQL using Docker:
+    ```bash
+    docker run         -p 5455:5432         -d         --name postgres-LightRag         shangor/postgres-for-rag:v1.0         sh -c "service postgresql start && sleep infinity"
+    ```
+
+    Example:
+        ```python
+        from gllm_inference.em_invoker import OpenAIEMInvoker
+        from gllm_inference.lm_invoker import OpenAILMInvoker
+        from gllm_docproc.indexer.graph.light_rag_graph_rag_indexer import LightRAGGraphRAGIndexer
+        from gllm_datastore.graph_data_store.light_rag_postgres_data_store import LightRAGPostgresDataStore
+
+        # Create the LightRAGPostgresDataStore instance
+        graph_store = LightRAGPostgresDataStore(
+            lm_invoker=OpenAILMInvoker(model_name="gpt-4o-mini"),
+            em_invoker=OpenAIEMInvoker(model_name="text-embedding-3-small"),
+            postgres_db_host="localhost",
+            postgres_db_port=5455,
+            postgres_db_user="rag",
+            postgres_db_password="rag",
+            postgres_db_name="rag",
+            postgres_db_workspace="default",
+        )
+
+
+        # Create the indexer
+        indexer = LightRAGGraphRAGIndexer(graph_store=graph_store)
+
+        # Create elements to index
+        elements = [
+            {
+                "text": "This is a sample document about AI.",
+                "structure": "uncategorized",
+                "metadata": {
+                    "source": "sample.txt",
+                    "source_type": "TEXT",
+                    "loaded_datetime": "2025-07-10T12:00:00",
+                    "chunk_id": "chunk_001",
+                    "file_id": "file_001"
+                }
+            }
+        ]
+
+        # Index the elements
+        indexer.index(elements)
+        ```
+
+    Attributes:
+        _graph_store (BaseLightRAGDataStore): The LightRAG data store used for indexing and querying.
+    '''
+    def __init__(self, graph_store: BaseLightRAGDataStore) -> None:
+        """Initialize the LightRAGGraphRAGIndexer.
+
+        Args:
+            graph_store (BaseLightRAGDataStore): The LightRAG instance to use for indexing.
+        """
+    def index(self, elements: list[dict[str, Any]], **kwargs: Any) -> None:
+        """Index elements into the LightRAG system and create graph relationships.
+
+        This method extracts text and chunk IDs from the provided elements,
+        inserts them into the LightRAG system, and creates a graph structure
+        connecting files to chunks.
+
+        Args:
+            elements (list[dict[str, Any]]): List of Element objects containing text and metadata.
+                Each element should have a metadata attribute with a chunk_id and a file_id.
+            **kwargs (Any): Additional keyword arguments.
+        """
+    def delete(self, file_id: str | None = None, chunk_id: str | None = None, entity_id: str | None = None, **kwargs: Any) -> None:
+        """Delete entities from the LightRAG system and graph.
+
+        Supports multiple deletion modes based on the provided keyword arguments.
+        Exactly one of the supported deletion parameters must be provided.
+
+        Args:
+            file_id (str, optional): Delete a file and all its associated chunks. Defaults to None.
+            chunk_id (str, optional): Delete a specific chunk entity. Defaults to None.
+            entity_id (str, optional): Delete a specific entity or node. Defaults to None.
+            **kwargs (Any): Additional keyword arguments.
+
+        Raises:
+            ValueError: If no deletion parameter is provided or multiple are provided.
+        """
+    def resolve_entities(self) -> None:
+        """Resolve entities from the graph.
+
+        Currently, this method does nothing. Resolve entities
+        has been implicitly implemented in the LightRAG instance.
+        """

gllm_docproc/indexer/graph/llama_index_graph_rag_indexer.pyi

@@ -0,0 +1,79 @@
+from _typeshed import Incomplete
+from gllm_datastore.graph_data_store.llama_index_graph_rag_data_store import LlamaIndexGraphRAGDataStore
+from gllm_docproc.indexer.graph.graph_rag_indexer import BaseGraphRAGIndexer as BaseGraphRAGIndexer
+from gllm_docproc.indexer.graph.utils.schema_validator import validate_kg_schema as validate_kg_schema
+from gllm_docproc.model.element import Element as Element
+from llama_index.core.base.embeddings.base import BaseEmbedding
+from llama_index.core.base.llms.base import BaseLLM
+from llama_index.core.schema import TransformComponent as TransformComponent
+from llama_index.core.vector_stores.types import BasePydanticVectorStore
+from typing import Any
+
+logger: Incomplete
+
+class LlamaIndexGraphRAGIndexer(BaseGraphRAGIndexer):
+    """Indexer for graph RAG using LlamaIndex.
+
+    Attributes:
+        _index (PropertyGraphIndex): Property graph index.
+        _graph_store (LlamaIndexGraphRAGDataStore): Storage for property graph.
+        _strict_mode (bool): Whether strict schema validation is enabled.
+    """
+    def __init__(self, graph_store: LlamaIndexGraphRAGDataStore, llama_index_llm: BaseLLM | None = None, allowed_entity_types: list[str] | None = None, allowed_relation_types: list[str] | None = None, kg_validation_schema: dict[str, list[str]] | None = None, strict_mode: bool = False, kg_extractors: list[TransformComponent] | None = None, embed_model: BaseEmbedding | None = None, vector_store: BasePydanticVectorStore | None = None, max_triplets_per_chunk: int = 10, num_workers: int = 4, **kwargs: Any) -> None:
+        '''Initialize the LlamaIndexGraphRAGIndexer.
+
+        Args:
+            graph_store (LlamaIndexGraphRAGDataStore): Storage for property graph.
+            llama_index_llm (BaseLLM | None, optional): Language model for LlamaIndex. Defaults to None.
+            allowed_entity_types (list[str] | None, optional): List of allowed entity types. When strict_mode=True,
+                only these types are extracted. When strict_mode=False, serves as hints. Defaults to None.
+            allowed_relation_types (list[str] | None, optional): List of allowed relationship types. Behavior depends
+                on strict_mode. Defaults to None.
+            kg_validation_schema (dict[str, list[str]] | None, optional): Validation schema for
+                strict mode. Maps entity types to their allowed outgoing relationship types.
+                Format:
+                {"ENTITY_TYPE": ["ALLOWED_REL1", "ALLOWED_REL2"], ...}
+                Example: {"PERSON": ["WORKS_AT", "FOUNDED"], "ORGANIZATION": ["LOCATED_IN"]}
+                Defaults to None.
+            strict_mode (bool, optional): If True, uses SchemaLLMPathExtractor with strict validation.
+                If False (default), uses DynamicLLMPathExtractor with optional guidance. Defaults to False.
+            kg_extractors (list[TransformComponent] | None, optional): Custom list of extractors.
+                If provided, overrides automatic extractor selection based on strict_mode. Defaults to None.
+            embed_model (BaseEmbedding | None, optional): Embedding model for vector representations. Defaults to None.
+            vector_store (BasePydanticVectorStore | None, optional): Storage for vector data. Defaults to None.
+            max_triplets_per_chunk (int, optional): Maximum triplets to extract per chunk. Defaults to 10.
+            num_workers (int, optional): Number of parallel workers. Defaults to 4.
+            **kwargs (Any): Additional keyword arguments.
+        '''
+    def index(self, elements: list[Element] | list[dict[str, Any]], **kwargs: Any) -> None:
+        """Index elements into the graph.
+
+        This method indexes elements into the graph.
+
+        Notes:
+        - Currently only Neo4jPropertyGraphStore that is supported for indexing the metadata from the TextNode.
+        - The 'document_id' parameter is used to specify the document ID for the elements.
+        - The 'chunk_id' parameter is used to specify the chunk ID for the elements.
+
+        Args:
+            elements (list[Element] | list[dict[str, Any]]): List of elements or list of dictionaries representing
+                elements to be indexed.
+            **kwargs (Any): Additional keyword arguments.
+        """
+    def resolve_entities(self) -> None:
+        """Resolve entities in the graph.
+
+        Currently, this method does nothing.
+        """
+    def delete(self, **kwargs: Any) -> None:
+        """Delete elements from the knowledge graph.
+
+        This method deletes elements from the knowledge graph based on the provided document_id.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments.
+
+        Raises:
+            ValueError: If document_id is not provided.
+            Exception: If an error occurs during deletion.
+        """

gllm_docproc/indexer/vector/__init__.pyi

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

gllm_docproc/indexer/vector/vector_db_indexer.pyi

@@ -0,0 +1,53 @@
+from _typeshed import Incomplete
+from gllm_datastore.core.capabilities import VectorCapability
+from gllm_docproc.indexer import BaseIndexer as BaseIndexer
+from gllm_docproc.model.element import Element as Element
+from gllm_inference.schema import Vector as Vector
+from typing import Any, TypeVar
+
+T = TypeVar('T')
+
+class VectorDBIndexer(BaseIndexer):
+    """Index elements into a vector datastore capability."""
+    logger: Incomplete
+    vector_capability: Incomplete
+    def __init__(self, vector_capability: VectorCapability) -> None:
+        """Initialize the indexer with an optional vector capability instance.
+
+        Args:
+            vector_capability (VectorCapability): The capability implementation
+                (for example, `ElasticsearchVectorCapability`) that will receive
+                chunks for indexing operations. Must be set before calling
+                indexing methods.
+        """
+    def index(self, elements: list[dict[str, Any]], **kwargs: Any) -> None:
+        """Index elements into the configured vector capability.
+
+        Args:
+            elements (list[dict[str, Any]]): Parsed elements containing text and metadata.
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Kwargs:
+            replace_file_id (str, optional): File identifier to be replaced before indexing.
+                Defaults to None. If provided, existing records for this file_id are removed first.
+            batch_size (int, optional): The number of chunks to process in each batch.
+                Defaults to 100.
+            max_retries (int, optional): The maximum number of retry attempts for failed batches.
+                Defaults to 3.
+            vectors (list[Vector] | None, optional): Pre-computed vectors for the elements.
+                If provided, uses create_from_vector instead of create. Must match the length
+                of elements. Defaults to None.
+
+        Raises:
+            Exception: If an error occurs during indexing.
+        """
+    def delete(self, **kwargs: Any) -> None:
+        """Delete documents from the vector capability based on the file ID.
+
+        Kwargs:
+            file_id (str): The ID of the file(s) to be deleted.
+
+        Raises:
+            ValueError: If file_id is not provided.
+            Exception: If an error occurs during deletion.
+        """

gllm_docproc/loader/__init__.pyi

@@ -0,0 +1,4 @@
+from .base_loader import BaseLoader as BaseLoader
+from .pipeline_loader import PipelineLoader as PipelineLoader
+
+__all__ = ['BaseLoader', 'PipelineLoader']

gllm_docproc/loader/audio/__init__.pyi

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

gllm_docproc/loader/audio/audio_loader.pyi

@@ -0,0 +1,45 @@
+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, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import AUDIO as AUDIO, ElementMetadata as ElementMetadata
+from gllm_multimodal.modality_converter.audio_to_text.audio_to_text import BaseAudioToText as BaseAudioToText
+from gllm_multimodal.modality_converter.schema import AudioTranscript as AudioTranscript
+from typing import Any
+
+class AudioLoader(BaseLoader):
+    """Audio Loader class.
+
+    This class provides a loader for audio files for extracting information from audio files
+    using GLLM Multimodal Audio to Text. It implements the 'load' method to handle document loading
+    from a given source.
+
+    Attributes:
+        audio_to_text_converters (list[BaseAudioToText]): A list of audio to text converter from GLLM Multimodal.
+    """
+    audio_to_text_converters: Incomplete
+    logger: Incomplete
+    def __init__(self, audio_to_text_converters: list[BaseAudioToText] | None = None) -> None:
+        """Initialize the AudioLoader class.
+
+        Args:
+            audio_to_text_converters (list[BaseAudioToText] | None): A list of audio to text converters.
+                If None, defaults to using YouTubeTranscriptAudioToText and OpenAIWhisperAudioToText.
+        """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process audio file using the GLLM Multimodal Audio to Text.
+
+        This method will transcribe the audio file using the GLLM Multimodal Audio to Text. It will then convert the
+        transcription results to elements.
+
+        Args:
+            source (str): The source of the audio file to be transcribed.
+            loaded_elements (Any): The loaded elements to be processed.
+            **kwargs (Any): Additional keyword arguments for the loader
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements.
+        """

gllm_docproc/loader/base_loader.pyi

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseLoader(ABC):
+    """An abstract base class for document loaders.
+
+    This class defines the structure for loading and processing documents to retrieve
+    required values. Subclasses are expected to implement the 'load' method
+    to handle document loading from a given source.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Abstract method to load a document.
+    """
+    @abstractmethod
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> Any:
+        """Load and process a document.
+
+        This method is abstract and must be implemented in subclasses.
+        It defines the process of loading a document using its source.
+
+        Args:
+            source (str): Might be file path, URL, the content itself.
+            loaded_elements (Any): The loaded elements from previous loaders. ideally formatted as List[Dict].
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            Any: The loaded document, ideally formatted as List[Dict]. Each dictionary within
+                the list are recommended to follows the structure of model 'Element',
+                to ensure consistency and ease of use across Document Processing Orchestrator.
+        """

gllm_docproc/loader/csv/__init__.pyi

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

gllm_docproc/loader/csv/pandas_loader.pyi

@@ -0,0 +1,53 @@
+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.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import CSV as CSV, ElementMetadata as ElementMetadata
+from typing import Any
+
+CSV_VARIANTS: Incomplete
+
+class PandasLoader(BaseLoader):
+    """A class used to load and process delimited text files using the pandas library.
+
+    This class inherits from the BaseLoader class and overrides its methods to provide
+    functionality for loading delimited text files with different separators:
+    - CSV (Comma-Separated Values): Uses commas (,) as separators between values
+    - TSV (Tab-Separated Values): Uses tabs (\\t) as separators between values
+    - PSV (Pipe-Separated Values): Uses pipe characters (|) as separators between values
+    - SSV (Space-Separated Values): Uses spaces as separators between values
+
+    It provides methods to extract tables from the document and convert them into elements.
+
+    Methods:
+        load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any)
+            -> list[dict[str, Any]]: Load a delimited text file.
+    """
+    logger: Incomplete
+    def __init__(self) -> None:
+        """Initialize the PandasLoader class."""
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load a delimited text file.
+
+        This method loads a delimited text file (CSV, TSV, PSV, SSV) and extracts the table elements.
+        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 delimited text file 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.
+            sep (str, optional): Delimiter to use. If not provided, will be auto-detected.
+            encoding (str, optional): Encoding to use. Defaults to 'utf-8'.
+            header (int | None, optional): Row number (0-based index) to use as column names.
+                If None, no header row is assumed and numeric column names are generated.
+
+        Returns:
+            list[dict[str, Any]]: The loaded elements from the delimited text file.
+
+        Raises:
+            UnsupportedFileExtensionError: If the file extension is not supported.
+        """

gllm_docproc/loader/docx/__init__.pyi

@@ -0,0 +1,5 @@
+from .docx2python_loader import DOCX2PythonLoader as DOCX2PythonLoader
+from .python_docx_loader import PythonDOCXLoader as PythonDOCXLoader
+from .python_docx_table_loader import PythonDOCXTableLoader as PythonDOCXTableLoader
+
+__all__ = ['PythonDOCXLoader', 'PythonDOCXTableLoader', 'DOCX2PythonLoader']

gllm_docproc/loader/docx/docx2python_loader.pyi

@@ -0,0 +1,46 @@
+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, trim_table_empty_cells as trim_table_empty_cells, validate_file_extension as validate_file_extension
+from gllm_docproc.model.element import Element as Element, FOOTER as FOOTER, HEADER as HEADER, IMAGE as IMAGE, TABLE as TABLE, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import DOCX as DOCX, ElementMetadata as ElementMetadata
+from gllm_docproc.model.media import Media as Media, MediaSourceType as MediaSourceType, MediaType as MediaType
+from typing import Any
+
+class DOCX2PythonLoader(BaseLoader):
+    """A class for loading and processing DOCX document using docx2python library.
+
+    This class defines the structure for loading and processing DOCX document to retrieve required values
+    (text, table, image, header, footer footnote, endnote). It implements the 'load' method to handle DOCX loading
+    from a given file path.
+
+    DOCX2PythonLoader is used to extract the text, table, image, header, footer, footnote, endnote
+    from the DOCX document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a DOCX document.
+    """
+    duplicate_merged_cells: Incomplete
+    def __init__(self, duplicate_merged_cells: bool = True) -> None:
+        """Initialize the DOCX2PythonLoader.
+
+        Args:
+            duplicate_merged_cells (bool): A boolean value indicating whether to duplicate merged cells.
+        """
+    def load(self, source: str, loaded_elements: list[dict[str, str]] | None = None, **kwargs: Any) -> list[dict[str, str]]:
+        """Load and process a DOCX document specified by the file path and name (source).
+
+        This method defines the process of loading a DOCX document using its file path.
+        It extracts the text, table, image, header, footer, footnote, endnote from the DOCX document.
+
+        Args:
+            source (str): The file path of the DOCX document.
+            loaded_elements (list[dict[str, str]] | None): A list of loaded elements containing text content
+                and metadata.
+            **kwargs (Any): Additional keyword arguments for loading the DOCX document.
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, str]]: A list of dictionaries containing loaded content and metadata.
+        """