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

gllm_docproc/chunker/__init__.pyi

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

gllm_docproc/chunker/base_chunker.pyi

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseChunker(ABC):
+    """An abstract base class for chunker.
+
+    This class segmenting or chunking elements based on contextual information.
+    Subclasses are expected to implement the 'chunk' method to handle chunking elements.
+
+    Methods:
+        chunk(elements, **kwargs): Abstract method to chunk a document.
+    """
+    @abstractmethod
+    def chunk(self, elements: Any, **kwargs: Any) -> Any:
+        """Chunk a document.
+
+        This method is abstract and must be implemented in subclasses.
+        It defines the process of chunking information from elements.
+
+        Args:
+            elements (Any): The information to be chunked. ideally formatted as List[Dict].
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            Any: The chunked information, 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/chunker/structured_element/__init__.pyi

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

gllm_docproc/chunker/structured_element/chunk_enricher.pyi

@@ -0,0 +1,43 @@
+from gllm_docproc.model.element import Element as Element
+from gllm_docproc.model.element_metadata import AUDIO as AUDIO, PDF as PDF, VIDEO as VIDEO
+
+def enrich_chunk(chunk: Element, elements: list[Element]) -> Element:
+    """Enrich the chunk with information from the original elements.
+
+    This is the default enrichment function for structured element chunker.
+    The function enrich the chunk with information from the original elements.
+    Based on the source type, the information that we want to keep are different.
+
+    Args:
+        chunk (Element): The chunk to be enriched.
+        elements (list[Element]): The original elements that form the chunk.
+
+    Returns:
+        Element: The enriched chunk.
+    """
+def enrich_pdf_chunk(chunk: Element, elements: list[Element]) -> Element:
+    """The default function for enriching the PDF chunk.
+
+    The function enriches the PDF chunk with the coordinates and page_number information
+    of the original elements.
+
+    Args:
+        chunk (Element): The PDF chunk to be enriched.
+        elements (list[Element]): The original elements that form the chunk.
+
+    Returns:
+        Element: The enriched PDF chunk.
+    """
+def enrich_audio_chunk(chunk: Element, elements: list[Element]) -> Element:
+    """The default function for enriching the audio chunk.
+
+    The function enriches the audio chunk by replacing the double newlines with a single newline.
+    Then, it adds the start_time, end_time, and lang_id information of the original elements.
+
+    Args:
+        chunk (Element): The audio chunk to be enriched.
+        elements (list[Element]): The original elements that form the chunk.
+
+    Returns:
+        Element: The enriched audio chunk.
+    """

gllm_docproc/chunker/structured_element/structured_element_chunker.pyi

@@ -0,0 +1,80 @@
+from _typeshed import Incomplete
+from gllm_docproc.chunker.base_chunker import BaseChunker as BaseChunker
+from gllm_docproc.chunker.structured_element.chunk_enricher import enrich_chunk as enrich_chunk
+from gllm_docproc.chunker.table import TableChunker as TableChunker
+from gllm_docproc.model.element import AUDIO as AUDIO, Element as Element, FOOTER as FOOTER, FOOTNOTE as FOOTNOTE, HEADER as HEADER, HEADING as HEADING, IMAGE as IMAGE, PAGE as PAGE, TABLE as TABLE, TITLE as TITLE, UNCATEGORIZED_TEXT as UNCATEGORIZED_TEXT, VIDEO as VIDEO
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from typing import Any
+
+NON_TEXT_STRUCTURE: Incomplete
+
+def default_text_splitter() -> RecursiveCharacterTextSplitter:
+    '''Define the default text splitter for structured text chunking.
+
+    This function defines the default text splitter for structured text chunking.
+    The text splitter is defined with the following separators:
+
+        1. "\\n#" : Split by Title or Heading
+        2. "\\n\\n" : Split between Paragraph Elements
+        3. "\\n" : Split between Title/Heading and Paragraph Elements
+        4. ". " | "! " | "? " : Split by Sentence
+        5. ", " : Split by Word
+        6. " " : Split by Word
+        7. "" : Split by Character
+
+    Returns:
+        RecursiveCharacterTextSplitter: A RecursiveCharacterTextSplitter object for structured text chunking.
+    '''
+
+class StructuredElementChunker(BaseChunker):
+    """A class for structured text chunker.
+
+    This class defines the structure for chunking structured text into smaller chunks. It implements
+    the 'chunk' method to handle structured text chunking.
+
+    Methods:
+        chunk(elements, **kwargs): Chunk the structured text into smaller chunks.
+    """
+    default_text_splitter: Incomplete
+    default_table_chunker: Incomplete
+    text_splitter: Incomplete
+    table_chunker: Incomplete
+    is_parent_structure_info_included: Incomplete
+    def __init__(self, text_splitter: RecursiveCharacterTextSplitter = ..., table_chunker: BaseChunker = ..., is_parent_structure_info_included: bool = True) -> None:
+        """Initialize the structured text chunker.
+
+        Args:
+            text_splitter (RecursiveCharacterTextSplitter): A RecursiveCharacterTextSplitter object
+                for structured text chunking.
+            table_chunker (BaseChunker): A BaseChunker object for table chunking.
+            is_parent_structure_info_included (bool): A boolean value to include parent structure
+                information in the chunk.
+        """
+    def chunk(self, elements: list[dict[str, Any]], **kwargs: Any) -> list[dict[str, Any]]:
+        '''Chunk the structured text into smaller chunks.
+
+        This method defines the process of chunking structured text into smaller chunks. It uses the
+        RecursiveCharacterTextSplitter to split the text into chunks based on the defined separators.
+
+        The method will split the text recursively based on the defined separators, or by default:
+            1. "\\n#" : Split by Title or Heading
+            2. "\\n\\n" : Split between Paragraph Elements
+            3. "\\n" : Split between Title/Heading and Paragraph Elements
+            4. ". " | "! " | "? " : Split by Sentence
+            5. ", " : Split by Word
+            6. " " : Split by Word
+            7. "" : Split by Character
+
+        Kwargs:
+            excluded_structures (list[str]): A list of structures to be excluded from the chunking process.
+            enrich_chunk (Callable[[Element, list[Element]], Element]): A function to enrich the chunked element.
+            file_id (str | None): The file id of the chunked elements. Defaults to None.
+
+        Args:
+            elements (list[dict[str, any]]): A list of dictionaries containing text and structure.
+            **kwargs (Any): Additional keyword arguments for the chunker.
+
+        Returns:
+            list[dict[str, Any]]: A list of dictionaries containing chunked text and metadata.
+        '''

gllm_docproc/chunker/table/__init__.pyi

@@ -0,0 +1,3 @@
+from .table_chunker import CSV as CSV, HTML as HTML, MARKDOWN as MARKDOWN, TableChunker as TableChunker
+
+__all__ = ['CSV', 'HTML', 'MARKDOWN', 'TableChunker']

gllm_docproc/chunker/table/table_chunker.pyi

@@ -0,0 +1,45 @@
+from _typeshed import Incomplete
+from gllm_docproc.chunker.base_chunker import BaseChunker as BaseChunker
+from gllm_docproc.model.element import Element as Element, TABLE as TABLE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata
+from typing import Any
+
+MARKDOWN: str
+CSV: str
+HTML: str
+
+class TableChunker(BaseChunker):
+    """Table Chunker class.
+
+    This class is used to chunk a table element into smaller chunks. It implements the 'chunk' method
+    to handle chunking the table element based on the chunk size and overlap. The table is converted
+    into the expected format (markdown, csv, or html).
+
+    Methods:
+        chunk(elements, **kwargs): Chunk a table element into smaller chunks.
+    """
+    chunk_size: Incomplete
+    chunk_overlap: Incomplete
+    table_format: Incomplete
+    table_splitter: Incomplete
+    def __init__(self, chunk_size: int = 4000, chunk_overlap: int = 0, table_format: str = ...) -> None:
+        """Initializes the TableChunker class.
+
+        Args:
+            chunk_size (int): The size of each chunk.
+            chunk_overlap (int): The overlap between each chunk.
+            table_format (str): The format of the table (markdown, csv, or html).
+        """
+    def chunk(self, elements: list[dict[str, Any]], **kwargs: Any) -> list[dict[str, Any]]:
+        """Chunk a table element into smaller chunks.
+
+        This method chunks a table element into smaller chunks based on the chunk size and overlap.
+        It converts the table into the expected format (markdown, csv, or html) and then chunks the table.
+
+        Args:
+            elements (list[dict[str, Any]]): The table element to be chunked.
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            list[dict[str, Any]]: The list of smaller chunks.
+        """

gllm_docproc/converter/__init__.pyi

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

gllm_docproc/converter/base_converter.pyi

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+
+class BaseConverter(ABC):
+    """Base class for document converter."""
+    @abstractmethod
+    def convert(self, path_input: str, path_output: str) -> None:
+        """Converts a document.
+
+        Args:
+            path_input (str): The path of the document to be converted.
+            path_output (str): The path of the converted document.
+
+        Returns:
+            None
+        """

gllm_docproc/data_generator/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_docproc.data_generator.base_data_generator import BaseDataGenerator as BaseDataGenerator
+from gllm_docproc.data_generator.image_data_generator.image_caption_data_generator import ImageCaptionDataGenerator as ImageCaptionDataGenerator
+from gllm_docproc.data_generator.image_data_generator.multi_model_image_caption_data_generator import MultiModelImageCaptionDataGenerator as MultiModelImageCaptionDataGenerator
+
+__all__ = ['BaseDataGenerator', 'ImageCaptionDataGenerator', 'MultiModelImageCaptionDataGenerator']

gllm_docproc/data_generator/base_data_generator.pyi

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseDataGenerator(ABC):
+    """Base class for data generator."""
+    @abstractmethod
+    def generate(self, elements: Any, **kwargs: Any) -> Any:
+        """Generates data for a list of chunks.
+
+        Args:
+            elements (Any): The elements to be used for generating data / metadata. ideally formatted as List[Dict].
+            **kwargs (Any): Additional keyword arguments for customization.
+
+        Returns:
+            Any: The generated data, 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/data_generator/image_data_generator/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_docproc.data_generator.image_data_generator.image_caption_data_generator import ImageCaptionDataGenerator as ImageCaptionDataGenerator
+from gllm_docproc.data_generator.image_data_generator.multi_model_image_caption_data_generator import MultiModelImageCaptionDataGenerator as MultiModelImageCaptionDataGenerator
+
+__all__ = ['ImageCaptionDataGenerator', 'MultiModelImageCaptionDataGenerator']

gllm_docproc/data_generator/image_data_generator/image_caption_data_generator.pyi

@@ -0,0 +1,40 @@
+from _typeshed import Incomplete
+from gllm_docproc.data_generator.base_data_generator import BaseDataGenerator as BaseDataGenerator
+from gllm_docproc.model.element import Element as Element, PAGE as PAGE
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, IMAGE as IMAGE
+from gllm_multimodal.modality_converter.image_to_text.image_to_caption.image_to_caption import BaseImageToCaption
+from typing import Any
+
+class ImageCaptionDataGenerator(BaseDataGenerator):
+    """Data generator for creating captions from images using BaseImageToCaption."""
+    DEFAULT_ELEMENT_PROCESSING_LIMIT: int
+    image_to_caption: Incomplete
+    def __init__(self, image_to_caption: BaseImageToCaption) -> None:
+        """Initialize the ImageCaptionDataGenerator.
+
+        Args:
+            image_to_caption (BaseImageToCaption): The image to caption converter instance.
+        """
+    def generate(self, elements: list[dict[str, Any]], **kwargs: Any) -> list[dict[str, Any]]:
+        """Generates captions by processing images in the input elements.
+
+        Args:
+            elements (list[dict[str, Any]]): List of dictionaries containing image data.
+                Each dictionary should have an 'image_source' key with the image location.
+            **kwargs (Any): Additional keyword arguments for the image captioning process.
+
+        Kwargs:
+            image_format_func (Callable[[str, Element], str], optional): Function to format the caption text.
+                Defaults to None.
+            element_processing_limit (int, optional): The maximum number of elements to process at a time.
+                Defaults to 100.
+            use_image_text_as_context (bool, optional): Whether to use the image text as context.
+                If set to False, will use `image_description` instead. Defaults to False.
+
+        Returns:
+            list[dict[str, Any]]: List of dictionaries containing the processed image data.
+                Each dictionary will contain the original data.
+
+        Raises:
+            ValueError: If elements don't contain required image information.
+        """

gllm_docproc/data_generator/image_data_generator/multi_model_image_caption_data_generator.pyi

@@ -0,0 +1,51 @@
+from _typeshed import Incomplete
+from gllm_docproc.data_generator.base_data_generator import BaseDataGenerator as BaseDataGenerator
+from gllm_docproc.data_generator.image_data_generator.image_caption_data_generator import ImageCaptionDataGenerator as ImageCaptionDataGenerator
+from gllm_docproc.model.element import IMAGE as IMAGE
+from typing import Any
+
+DEFAULT_MODEL_ID: str
+
+class MultiModelImageCaptionDataGenerator(BaseDataGenerator):
+    """Multi-model image captioning data generator with lazy initialization.
+
+    This class extends BaseDataGenerator to provide a data generator for image captioning that supports multiple models
+    with lazy initialization, to avoid API key validation during pipeline initialization.
+
+    Key Features:
+    1. Supports multiple models in a single instance.
+    2. Lazy initialization to avoid API key validation during initialization.
+    3. Dynamic model selection at runtime.
+    """
+    model_api_keys: Incomplete
+    logger: Incomplete
+    def __init__(self, model_api_keys: dict[str, str] | None = None) -> None:
+        """Initialize the MultiModelImageCaptionDataGenerator.
+
+        Args:
+            model_api_keys (dict[str, str] | None, optional): Dictionary mapping model IDs to their API keys.
+                Defaults to None, in which case no API keys passed during LMInvoker initialization.
+        """
+    def generate(self, elements: list[dict[str, Any]], **kwargs: Any) -> list[dict[str, Any]]:
+        '''Generate captions for elements with image structure.
+
+        Args:
+            elements (list[dict[str, Any]]): List of dictionaries containing elements to be processed.
+            **kwargs (Any): Additional keyword arguments for the image captioning process.
+
+        Kwargs:
+            model_id (str, optional): The ID of the model to use for image captioning.
+                Defaults to DEFAULT_MODEL_ID which is using the "google/gemini-2.5-flash".
+            system_prompt (str, optional): The system prompt to use for image captioning.
+                Defaults to DEFAULT_SYSTEM_PROMPT.
+            user_prompt (str, optional): The user prompt to use for image captioning.
+                Defaults to DEFAULT_USER_PROMPT.
+            default_hyperparameters (dict[str, Any]): Additional hyperparameters passed to
+                the LMInvoker configuration. Defaults to {}.
+            retry_config (dict[str, Any], optional): The retry config to use for the LM invoker.
+                If not provided, will use the default retry config. Defaults to {}.
+
+        Returns:
+            list[dict[str, Any]]: List of dictionaries containing the processed image data.
+                Each dictionary will contain the original data.
+        '''

gllm_docproc/data_generator/pii_data_generator/__init__.pyi

@@ -0,0 +1 @@
+from .pii_text_anonymization_data_generator import PIITextAnonymizationDataGenerator as PIITextAnonymizationDataGenerator

gllm_docproc/downloader/__init__.pyi

@@ -0,0 +1,5 @@
+from .base_downloader import BaseDownloader as BaseDownloader
+from .direct_file_url_downloader import DirectFileURLDownloader as DirectFileURLDownloader
+from .google_drive_downloader import GoogleDriveDownloader as GoogleDriveDownloader
+
+__all__ = ['BaseDownloader', 'DirectFileURLDownloader', 'GoogleDriveDownloader']

gllm_docproc/downloader/base_downloader.pyi

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+class BaseDownloader(ABC):
+    """Base class for document downloader."""
+    @abstractmethod
+    def download(self, source: str, output: str, **kwargs: Any) -> list[str] | None:
+        """Download source to the output directory.
+
+        Args:
+            source (str): The source to be downloaded.
+            output (str): The output directory where the downloaded source will be saved.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            list[str] | None: A list of file paths of successfully downloaded files.
+                If no files are downloaded, an empty list should be returned.
+                Returning None is only for backward compatibility and should be avoided in new implementations.
+        """

gllm_docproc/downloader/direct_file_url_downloader.pyi

@@ -0,0 +1,40 @@
+from _typeshed import Incomplete
+from gllm_docproc.downloader import BaseDownloader as BaseDownloader
+from typing import Any
+
+UNKNOWN_EXTENSION: str
+FALLBACK_EXTENSION: str
+MIME_TYPE_TO_EXTENSION_MAP: Incomplete
+
+class DirectFileURLDownloader(BaseDownloader):
+    """A class for downloading files from a direct file URL to the defined output directory."""
+    stream_buffer_size: Incomplete
+    max_retries: Incomplete
+    timeout: Incomplete
+    session: Incomplete
+    logger: Incomplete
+    def __init__(self, stream_buffer_size: int = 65536, max_retries: int = 3, timeout: int | None = None) -> None:
+        """Initialize the DirectFileURLDownloader.
+
+        Args:
+            stream_buffer_size (int, optional): The size of the buffer for streaming downloads in bytes.
+                Defaults to 64KB (65536 bytes).
+            max_retries (int, optional): The maximum number of retries for failed downloads. Defaults to 3.
+            timeout (int | None, optional): The timeout for the download request in seconds. Defaults to None.
+        """
+    def download(self, source: str, output: str, **kwargs: Any) -> list[str]:
+        """Download source to the output directory.
+
+        Args:
+            source (str): The source to be downloaded.
+            output (str): The output directory where the downloaded source will be saved.
+            **kwargs (Any): Additional keyword arguments.
+
+        kwargs:
+            ca_certs_path (str, optional): The path to the CA certificates file. Defaults to None.
+            extension (str, optional): The extension of the file to be downloaded. If not provided,
+                the extension will be detected from the response headers or content mime type.
+
+        Returns:
+            list[str]: A list of file paths of successfully downloaded files.
+        """

gllm_docproc/downloader/google_drive_downloader.pyi

@@ -0,0 +1,36 @@
+from _typeshed import Incomplete
+from gllm_docproc.downloader import BaseDownloader as BaseDownloader
+from typing import Any
+
+class GoogleDriveDownloader(BaseDownloader):
+    """A class for downloading files from Google Drive using BOSA connector for Google Drive integration."""
+    bosa: Incomplete
+    user: Incomplete
+    google_drive: Incomplete
+    logger: Incomplete
+    def __init__(self, api_key: str, identifier: str, secret: str, api_base_url: str = 'https://api.bosa.id') -> None:
+        '''Initialize the GoogleDriveDownloader.
+
+        Args:
+            api_key (str): The API key for the BOSA API.
+            identifier (str): The identifier for the BOSA user.
+            secret (str): The secret for the BOSA user.
+            api_base_url (str, optional): The base URL for the BOSA API. Defaults to "https://api.bosa.id".
+        '''
+    def download(self, source: str, output: str, **kwargs: Any) -> list[str]:
+        """Download a file from Google Drive to the output directory.
+
+        Args:
+            source (str): The Google Drive file ID or URL.
+            output (str): The output directory where the downloaded file will be saved.
+            **kwargs (Any): Additional keyword arguments.
+
+        Kwargs:
+            export_format (str, optional): The export format for the file.
+
+        Returns:
+            list[str]: A list containing the path(s) to the successfully downloaded file(s).
+
+        Raises:
+            ValueError: If file ID cannot be extracted or no files are returned from Google Drive.
+        """

gllm_docproc/downloader/html/__init__.pyi

@@ -0,0 +1,6 @@
+from . import utils as utils
+from .firecrawl_downloader import HTMLFirecrawlDownloader as HTMLFirecrawlDownloader
+from .html_downloader import HTMLDownloader as HTMLDownloader
+from .requests_downloader import RequestsDownloader as RequestsDownloader
+
+__all__ = ['HTMLDownloader', 'RequestsDownloader', 'HTMLFirecrawlDownloader', 'utils']

gllm_docproc/downloader/html/exception/__init__.pyi

@@ -0,0 +1,4 @@
+from .item_scrape_failed_exception import ItemScrapeFailedException as ItemScrapeFailedException
+from .zyte_api_key_not_provided_exception import ZyteApiKeyNotProvidedException as ZyteApiKeyNotProvidedException
+
+__all__ = ['ItemScrapeFailedException', 'ZyteApiKeyNotProvidedException']

gllm_docproc/downloader/html/exception/item_scrape_failed_exception.pyi

@@ -0,0 +1,16 @@
+from _typeshed import Incomplete
+
+class ItemScrapeFailedException(Exception):
+    """Exception raised when an item fails to be scraped.
+
+    Attributes:
+        message (str): Optional. The error message indicating the reason for the item scrape failure.
+    """
+    message: Incomplete
+    def __init__(self, message: str = 'Item failed to be scraped.') -> None:
+        '''Initialize the ItemScrapeFailedException.
+
+        Args:
+            message (str): Optional. The error message indicating the reason for the item scrape failure.
+                Defaults to "Item failed to be scraped."
+        '''

gllm_docproc/downloader/html/exception/zyte_api_key_not_provided_exception.pyi

@@ -0,0 +1,15 @@
+from _typeshed import Incomplete
+
+class ZyteApiKeyNotProvidedException(Exception):
+    """Custom exception raised when the Zyte API key is not provided.
+
+    Attributes:
+        message (str): Optional. The error message associated with the exception.
+    """
+    message: Incomplete
+    def __init__(self, message: str = 'Zyte API Key not provided.') -> None:
+        '''Initialize the ZyteApiKeyNotProvidedException.
+
+        Args:
+            message (str, optional): The error message associated with the exception.                 Defaults to "Zyte API Key not provided."
+        '''

gllm_docproc/downloader/html/firecrawl_downloader.pyi

@@ -0,0 +1,49 @@
+from _typeshed import Incomplete
+from gllm_docproc.downloader.base_downloader import BaseDownloader as BaseDownloader
+from gllm_docproc.downloader.html.utils.web_utils import generate_filename_from_url as generate_filename_from_url
+from gllm_docproc.model.element_metadata import ElementMetadata as ElementMetadata, HTML as HTML
+from gllm_docproc.utils.file_utils import save_to_json as save_to_json
+from typing import Any
+
+class HTMLFirecrawlDownloader(BaseDownloader):
+    """A downloader class for downloading web content using Firecrawl.
+
+    This class inherits from the BaseDownloader class and provides methods to download web content using Firecrawl.
+
+    Attributes:
+        firecrawl_instance (FirecrawlApp): The Firecrawl instance.
+    """
+    logger: Incomplete
+    firecrawl_instance: Incomplete
+    def __init__(self, api_key: str, api_url: str | None = None) -> None:
+        """Initialize the Firecrawl downloader.
+
+        Args:
+            api_key (str): The API key for Firecrawl.
+            api_url (str, optional): The API URL for Firecrawl.
+        """
+    def download(self, source: str, output: str, **kwargs: Any) -> list[str]:
+        """Download content and save to file as JSON.
+
+        Args:
+            source (str): The URL to scrape.
+            output (str): The directory path where the downloaded content (in JSON format) will be saved.
+            **kwargs (Any): Additional arguments to pass to the scraper.
+
+        Kwargs:
+            formats (list[str], optional): The formats to scrape. Supported formats include:
+                - markdown: Returns the markdown content of the page.
+                - html: Returns the processed HTML content of the page.
+                - rawHtml: Provides the unmodified, raw HTML content of the entire webpage.
+                - screenshot: Returns a screenshot of the page.
+                - screenshot@fullPage: Returns a screenshot of the full page.
+                - links: Extracts and returns a list of all links found on the scraped page.
+                - json: Allows for structured data extraction, Need to use `json_options` to define
+                        the schema for the output.
+
+                For a comprehensive list of supported formats, refer to the Firecrawl documentation.
+                Defaults to ['html'].
+
+        Returns:
+            list[str]: The list of full filepath of the created JSON files.
+        """