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

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.
+        """

gllm_docproc/loader/pdf/pymupdf_utils.pyi

@@ -0,0 +1,77 @@
+import fitz
+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 gllm_docproc.model.media import Media as Media, MediaSourceType as MediaSourceType, MediaType as MediaType
+from typing import Any
+
+def fix_image_with_transform(image_bytes: bytes, transform: tuple) -> bytes:
+    """Apply the PDF affine transform (a,b,c,d,e,f) to an image using only the image's pixel grid.
+
+    Ignores page size and DPI. Picks an output pixel size that preserves detail by default.
+    Optionally pass px_per_point to control output density yourself.
+
+    Args:
+        image_bytes: The image data as bytes.
+        transform: The PDF affine transform tuple (a,b,c,d,e,f).
+
+    Returns:
+        PNG bytes of the transformed image.
+    """
+def extract_image_element(image_instance: dict[str, Any], page_idx: int, element_metadata: ElementMetadata, page_layout_width: int, page_layout_height: int) -> Element | None:
+    """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 | None: An Element object containing image in base64 format and metadata.
+            None if the image is empty.
+    """
+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.
+    """
+def convert_page_to_image_base64(page: fitz.Page, dpi: int = 150) -> str:
+    """Convert a PDF page to a base64 encoded PNG image.
+
+    Args:
+        page (fitz.Page): The PDF page to convert.
+        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.
+
+    Returns:
+        str: Base64 encoded PNG image.
+    """
+def create_page_element(page_image_base64: str, page_number: int, page: fitz.Page, base_element_metadata: ElementMetadata, structure: str = ...) -> Element:
+    """Create a page element with the specified structure.
+
+    This function creates an Element representing a page with its image content.
+    It can be used to create either IMAGE or PAGE structure elements.
+
+    Args:
+        page_image_base64 (str): The page image in base64 format.
+        page_number (int): The page number.
+        page (fitz.Page): The PDF page.
+        base_element_metadata (ElementMetadata): The base element metadata.
+        structure (str, optional): The element structure type. Defaults to IMAGE.
+
+    Returns:
+        Element: The page element with the specified structure.
+    """

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.hybrid_cache.hybrid_cache import BaseHybridCache
+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: BaseHybridCache | None = None) -> None:
+        """Initialize the PipelineLoader.
+
+        Args:
+            cache_data_store (BaseHybridCache, 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/pptx/__init__.pyi

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

gllm_docproc/loader/pptx/python_pptx_loader.pyi

@@ -0,0 +1,48 @@
+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, IMAGE as IMAGE, PARAGRAPH as PARAGRAPH, TABLE as TABLE, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, PPTX as PPTX
+from gllm_docproc.model.media import Media as Media, MediaSourceType as MediaSourceType, MediaType as MediaType
+from typing import Any
+
+UNTITLED_CHART: str
+
+class PythonPPTXLoader(BaseLoader):
+    """A class for loading and processing PPTX documents using PythonPPTXLoader.
+
+    This class defines the structure for loading and processing a PPTX
+    document to retrieve the content from its slides.
+    It implements the 'load' method to handle PPTX loading from a given file path.
+
+    PythonPPTXLoader is used to extract individual slides and
+    their contents (such as text, tables, and images) and metadata from the PPTX document.
+
+    Methods:
+        load(source, loaded_elements, **kwargs): Load a PPTX document.
+    """
+    include_hidden_slides: Incomplete
+    logger: Incomplete
+    def __init__(self, include_hidden_slides: bool = False) -> None:
+        """Initialize loader with option to include hidden slides.
+
+        Args:
+            include_hidden_slides (bool, optional): Whether to include hidden slides during loading. Defaults to False.
+        """
+    def load(self, source: str, loaded_elements: list[dict[str, Any]] | None = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process a PPTX document specified by the file path and name (source).
+
+        This method defines the process of loading a PPTX document using its file path.
+        It is responsible for extracting content from each slide, such as text, tables, and images.
+
+        Args:
+            source (str): The path to the PPTX 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/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,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
+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.
+        is_text_file: Check if a file is a text file.
+    """
+    DEFAULT_SUPPORTED_PREFIX_MIME_TYPES: Incomplete
+    logger: Incomplete
+    supported_prefix_mime_types: Incomplete
+    def __init__(self, supported_prefix_mime_types: list[str] | None = None) -> None:
+        """Initialize the TXTLoader class.
+
+        Args:
+            supported_prefix_mime_types (list[str] | None, optional): The list of supported prefix mime types.
+        """
+    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.
+
+        This method loads a text file into a list of elements.
+        It uses the `is_text_file` method to check if the file is a text file.
+        If the file is not a text file, the method will raise a ValueError.
+
+        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.
+
+        Raises:
+            ValueError: If the file is not a text file.
+        """
+    def is_text_file(self, source: str) -> bool:
+        """Check if a file is a text file.
+
+        This method uses the `magic` library to check if a file is a text file.
+
+        Args:
+            source (str): The path to the file.
+
+        Returns:
+            bool: True if the file is a text file, False otherwise.
+        """

gllm_docproc/loader/video/__init__.pyi

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

gllm_docproc/loader/video/video_loader_utils.pyi

@@ -0,0 +1,97 @@
+import numpy as np
+from _typeshed import Incomplete
+from gllm_docproc.loader.exception import VideoConversionError as VideoConversionError
+
+logger: Incomplete
+DEFAULT_SAMPLE_RATE: int
+AUDIO_NORMALIZATION_FACTOR: float
+PCM_16_MAX_VALUE: int
+INT16_TO_FLOAT_DIVISOR: float
+GSTREAMER_MAX_BUFFERS: int
+
+def is_supported_video_file(file_path: str) -> bool:
+    """Validate if a file is a supported video format using intelligent MIME detection.
+
+    Args:
+        file_path (str): Absolute or relative path to the file to validate.
+
+    Returns:
+        bool: True if the file is a supported video format, False otherwise.
+    """
+def convert_video_to_audio_bytes(video_path: str, target_sample_rate: int | None = ..., normalize_audio: bool = True, audio_format: str = 'WAV', audio_subtype: str | None = None) -> bytes:
+    '''Convert video file to audio bytes optimized for audio transcription services using GStreamer.
+
+    This function provides a complete video-to-audio processing pipeline that:
+    1. Extracts audio from video using GStreamer
+    2. Processes and normalizes the audio signal
+    3. Resamples to target sample rate (optional)
+    4. Encodes to specified audio format with intelligent defaults
+    5. Returns audio bytes ready for transcription services or file output
+
+    Args:
+        video_path (str): Path to the input video file.
+
+        target_sample_rate (int | None, optional): Target sample rate for the audio output.
+            Common values:
+            - 16000 Hz: Optimal for speech recognition (default)
+            - 44100 Hz: CD quality, good for music transcription
+            - 48000 Hz: Professional audio standard
+            - None: Preserve original video\'s sample rate
+
+            Higher sample rates provide better quality but larger file sizes.
+            Most transcription services work best with 16kHz. Defaults to 16000.
+
+        normalize_audio (bool, optional): Whether to normalize audio amplitude.
+            Set to False if the transcription service handles its own normalization. Defaults to True.
+
+        audio_format (str, optional): Target audio format for the output. Case-insensitive.
+            **Recommended formats for transcription:**
+            - "WAV": Uncompressed, maximum compatibility (default)
+
+            See `audio_to_bytes()` documentation for complete format list.
+            Defaults to "WAV".
+
+        audio_subtype (str | None, optional): Audio encoding subtype.
+            If None, uses format defaults: WAV→"PCM_16", FLAC→"PCM_16", MP3→"MPEG_LAYER_III", OGG→"VORBIS".
+            Common options: "PCM_16", "PCM_24", "PCM_32", "FLOAT".
+            Defaults to None.
+
+    Returns:
+        bytes: Audio data in the specified format, ready for transcription services or file output.
+
+    Raises:
+        FileNotFoundError: If the video file doesn\'t exist.
+        ValueError: If unsupported format, no audio stream, or invalid format-subtype combination.
+        VideoConversionError: For other conversion failures (decoding, processing, encoding errors).
+
+    Examples:
+        >>> audio_bytes = convert_video_to_audio_bytes("meeting.mp4")  # Default: WAV, 16kHz
+        >>> audio_bytes = convert_video_to_audio_bytes("concert.mov", target_sample_rate=44100, audio_format="FLAC")
+        >>> audio_bytes = convert_video_to_audio_bytes("lecture.avi", audio_format="MP3")  # Smaller files
+    '''
+def audio_to_bytes(audio_data: np.ndarray, sample_rate: int, audio_format: str = 'WAV', subtype: str | None = None) -> bytes:
+    '''Convert audio data to specified format bytes.
+
+    Args:
+        audio_data (np.ndarray): Audio data as NumPy array.
+        sample_rate (int): Sample rate in Hz (e.g., 16000, 44100).
+        audio_format (str, optional): Target format. Supports WAV, FLAC, MP3, OGG, AIFF, etc.
+            See `soundfile.available_formats()` for the complete list.
+            Defaults to "WAV".
+        subtype (str | None, optional): Audio encoding subtype.
+            If None, uses soundfile\'s format defaults: WAV→"PCM_16", FLAC→"PCM_16", MP3→"MPEG_LAYER_III", OGG→"VORBIS".
+            See `soundfile.available_subtypes(format)` for the complete list.
+            Defaults to None.
+
+    Returns:
+        bytes: Audio data in the specified format.
+
+    Raises:
+        ValueError: If unsupported format/subtype or incompatible format-subtype combination.
+
+    Examples:
+        >>> audio_data = np.array([0.1, -0.2, 0.3], dtype=np.float32)
+        >>> wav_bytes = audio_to_bytes(audio_data, 16000)  # WAV + PCM_16
+        >>> flac_bytes = audio_to_bytes(audio_data, 44100, "FLAC")  # FLAC + PCM_16
+        >>> mp3_bytes = audio_to_bytes(audio_data, 16000, "MP3")  # MP3 + MPEG_LAYER_III
+    '''

gllm_docproc/loader/video/video_transcript_loader.pyi

@@ -0,0 +1,59 @@
+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.loader.video.video_loader_utils import convert_video_to_audio_bytes as convert_video_to_audio_bytes, is_supported_video_file as is_supported_video_file
+from gllm_docproc.model.element import Element as Element, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, VIDEO as VIDEO
+from gllm_docproc.utils import run_async_in_sync as run_async_in_sync
+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 VideoTranscriptLoader(BaseLoader):
+    """Video Transcript Loader class for comprehensive video processing.
+
+    This class provides a complete pipeline for processing video files by:
+    - Converting video to audio using GStreamer (supports MP4, AVI, MOV, MKV, WebM, etc.)
+    - Transcribing audio using configurable Audio-to-Text converters
+    - Processing transcript elements with enhanced metadata
+    - Converting structured elements to the GLLM format
+
+    Attributes:
+        audio_to_text_converters (list[BaseAudioToText]): List of audio transcription converters.
+        logger (Logger): Logger instance for the class.
+    """
+    logger: Incomplete
+    audio_to_text_converters: Incomplete
+    def __init__(self, audio_to_text_converters: list[BaseAudioToText] | None = None) -> None:
+        """Initialize the VideoTranscriptLoader class.
+
+        Args:
+            audio_to_text_converters (list[BaseAudioToText], optional): List of audio-to-text converters.
+                Defaults to OpenAI Whisper if not provided.
+        """
+    def load(self, source: str, loaded_elements: Any = None, **kwargs: Any) -> list[dict[str, Any]]:
+        """Load and process video file through the transcription pipeline.
+
+        This method processes a video file by:
+        1. Converting video to audio using GStreamer
+        2. Transcribing audio to text using configured Audio-to-Text converters
+        3. Converting transcripts to structured Element objects
+        4. Returning elements as a list of dictionaries
+
+        Supports any video format that GStreamer can handle (MP4, AVI, MOV, MKV, WebM, etc.).
+
+        Args:
+            source (str): Path to the video file.
+            loaded_elements (Any): The loaded elements from previous loaders (not used in this implementation).
+            **kwargs (Any): Additional keyword arguments (currently not used).
+
+        Kwargs:
+            original_source (str, optional): The original source of the document.
+
+        Returns:
+            list[dict[str, Any]]: List of video transcript elements as dictionaries.
+
+        Raises:
+            FileNotFoundError: If the video file doesn't exist.
+            ValueError: If the file is not a supported video format or if conversion/transcription fails.
+        """

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,36 @@
+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 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,7 @@
+from .element import Element as Element
+from .element_metadata import ElementMetadata as ElementMetadata
+from .loader_type import LoaderType as LoaderType
+from .media import Media as Media
+from .parser_type import ParserType as ParserType
+
+__all__ = ['Element', 'ElementMetadata', 'LoaderType', 'Media', 'ParserType']