lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/docling/chunk_docling_document.py

@@ -0,0 +1,186 @@
+import json
+
+import tiktoken
+from docling_core.transforms.chunker import BaseChunker, DocMeta
+from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker
+
+from lfx.base.data.docling_utils import extract_docling_documents
+from lfx.custom import Component
+from lfx.io import DropdownInput, HandleInput, IntInput, MessageTextInput, Output, StrInput
+from lfx.schema import Data, DataFrame
+
+
+class ChunkDoclingDocumentComponent(Component):
+    display_name: str = "Chunk DoclingDocument"
+    description: str = "Use the DocumentDocument chunkers to split the document into chunks."
+    documentation = "https://docling-project.github.io/docling/concepts/chunking/"
+    icon = "Docling"
+    name = "ChunkDoclingDocument"
+
+    inputs = [
+        HandleInput(
+            name="data_inputs",
+            display_name="Data or DataFrame",
+            info="The data with documents to split in chunks.",
+            input_types=["Data", "DataFrame"],
+            required=True,
+        ),
+        DropdownInput(
+            name="chunker",
+            display_name="Chunker",
+            options=["HybridChunker", "HierarchicalChunker"],
+            info=("Which chunker to use."),
+            value="HybridChunker",
+            real_time_refresh=True,
+        ),
+        DropdownInput(
+            name="provider",
+            display_name="Provider",
+            options=["Hugging Face", "OpenAI"],
+            info=("Which tokenizer provider."),
+            value="Hugging Face",
+            show=True,
+            real_time_refresh=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        StrInput(
+            name="hf_model_name",
+            display_name="HF model name",
+            info=(
+                "Model name of the tokenizer to use with the HybridChunker when Hugging Face is chosen as a tokenizer."
+            ),
+            value="sentence-transformers/all-MiniLM-L6-v2",
+            show=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        StrInput(
+            name="openai_model_name",
+            display_name="OpenAI model name",
+            info=("Model name of the tokenizer to use with the HybridChunker when OpenAI is chosen as a tokenizer."),
+            value="gpt-4o",
+            show=False,
+            advanced=True,
+            dynamic=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Maximum tokens",
+            info=("Maximum number of tokens for the HybridChunker."),
+            show=True,
+            required=False,
+            advanced=True,
+            dynamic=True,
+        ),
+        MessageTextInput(
+            name="doc_key",
+            display_name="Doc Key",
+            info="The key to use for the DoclingDocument column.",
+            value="doc",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="chunk_documents"),
+    ]
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
+        if field_name == "chunker":
+            provider_type = build_config["provider"]["value"]
+            is_hf = provider_type == "Hugging Face"
+            is_openai = provider_type == "OpenAI"
+            if field_value == "HybridChunker":
+                build_config["provider"]["show"] = True
+                build_config["hf_model_name"]["show"] = is_hf
+                build_config["openai_model_name"]["show"] = is_openai
+                build_config["max_tokens"]["show"] = True
+            else:
+                build_config["provider"]["show"] = False
+                build_config["hf_model_name"]["show"] = False
+                build_config["openai_model_name"]["show"] = False
+                build_config["max_tokens"]["show"] = False
+        elif field_name == "provider" and build_config["chunker"]["value"] == "HybridChunker":
+            if field_value == "Hugging Face":
+                build_config["hf_model_name"]["show"] = True
+                build_config["openai_model_name"]["show"] = False
+            elif field_value == "OpenAI":
+                build_config["hf_model_name"]["show"] = False
+                build_config["openai_model_name"]["show"] = True
+
+        return build_config
+
+    def _docs_to_data(self, docs) -> list[Data]:
+        return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
+
+    def chunk_documents(self) -> DataFrame:
+        documents = extract_docling_documents(self.data_inputs, self.doc_key)
+
+        chunker: BaseChunker
+        if self.chunker == "HybridChunker":
+            try:
+                from docling_core.transforms.chunker.hybrid_chunker import HybridChunker
+            except ImportError as e:
+                msg = (
+                    "HybridChunker is not installed. Please install it with `uv pip install docling-core[chunking] "
+                    "or `uv pip install transformers`"
+                )
+                raise ImportError(msg) from e
+            max_tokens: int | None = self.max_tokens if self.max_tokens else None
+            if self.provider == "Hugging Face":
+                try:
+                    from docling_core.transforms.chunker.tokenizer.huggingface import HuggingFaceTokenizer
+                except ImportError as e:
+                    msg = (
+                        "HuggingFaceTokenizer is not installed."
+                        " Please install it with `uv pip install docling-core[chunking]`"
+                    )
+                    raise ImportError(msg) from e
+                tokenizer = HuggingFaceTokenizer.from_pretrained(
+                    model_name=self.hf_model_name,
+                    max_tokens=max_tokens,
+                )
+            elif self.provider == "OpenAI":
+                try:
+                    from docling_core.transforms.chunker.tokenizer.openai import OpenAITokenizer
+                except ImportError as e:
+                    msg = (
+                        "OpenAITokenizer is not installed."
+                        " Please install it with `uv pip install docling-core[chunking]`"
+                        " or `uv pip install transformers`"
+                    )
+                    raise ImportError(msg) from e
+                if max_tokens is None:
+                    max_tokens = 128 * 1024  # context window length required for OpenAI tokenizers
+                tokenizer = OpenAITokenizer(
+                    tokenizer=tiktoken.encoding_for_model(self.openai_model_name), max_tokens=max_tokens
+                )
+            chunker = HybridChunker(
+                tokenizer=tokenizer,
+            )
+        elif self.chunker == "HierarchicalChunker":
+            chunker = HierarchicalChunker()
+
+        results: list[Data] = []
+        try:
+            for doc in documents:
+                for chunk in chunker.chunk(dl_doc=doc):
+                    enriched_text = chunker.contextualize(chunk=chunk)
+                    meta = DocMeta.model_validate(chunk.meta)
+
+                    results.append(
+                        Data(
+                            data={
+                                "text": enriched_text,
+                                "document_id": f"{doc.origin.binary_hash}",
+                                "doc_items": json.dumps([item.self_ref for item in meta.doc_items]),
+                            }
+                        )
+                    )
+
+        except Exception as e:
+            msg = f"Error splitting text: {e}"
+            raise TypeError(msg) from e
+
+        return DataFrame(results)

lfx/components/docling/docling_inline.py

@@ -0,0 +1,231 @@
+import time
+from multiprocessing import Queue, get_context
+from queue import Empty
+
+from lfx.base.data import BaseFileComponent
+from lfx.base.data.docling_utils import docling_worker
+from lfx.inputs import DropdownInput
+from lfx.schema import Data
+
+
+class DoclingInlineComponent(BaseFileComponent):
+    display_name = "Docling"
+    description = "Uses Docling to process input documents running the Docling models locally."
+    documentation = "https://docling-project.github.io/docling/"
+    trace_type = "tool"
+    icon = "Docling"
+    name = "DoclingInline"
+
+    # https://docling-project.github.io/docling/usage/supported_formats/
+    VALID_EXTENSIONS = [
+        "adoc",
+        "asciidoc",
+        "asc",
+        "bmp",
+        "csv",
+        "dotx",
+        "dotm",
+        "docm",
+        "docx",
+        "htm",
+        "html",
+        "jpeg",
+        "json",
+        "md",
+        "pdf",
+        "png",
+        "potx",
+        "ppsx",
+        "pptm",
+        "potm",
+        "ppsm",
+        "pptx",
+        "tiff",
+        "txt",
+        "xls",
+        "xlsx",
+        "xhtml",
+        "xml",
+        "webp",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        DropdownInput(
+            name="pipeline",
+            display_name="Pipeline",
+            info="Docling pipeline to use",
+            options=["standard", "vlm"],
+            real_time_refresh=False,
+            value="standard",
+        ),
+        DropdownInput(
+            name="ocr_engine",
+            display_name="OCR Engine",
+            info="OCR engine to use. None will disable OCR.",
+            options=["None", "easyocr", "tesserocr", "rapidocr", "ocrmac"],
+            real_time_refresh=False,
+            value="None",
+        ),
+        # TODO: expose more Docling options
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def _wait_for_result_with_process_monitoring(self, queue: Queue, proc, timeout: int = 300):
+        """Wait for result from queue while monitoring process health.
+
+        Handles cases where process crashes without sending result.
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            # Check if process is still alive
+            if not proc.is_alive():
+                # Process died, try to get any result it might have sent
+                try:
+                    result = queue.get_nowait()
+                except Empty:
+                    # Process died without sending result
+                    msg = f"Worker process crashed unexpectedly without producing result. Exit code: {proc.exitcode}"
+                    raise RuntimeError(msg) from None
+                else:
+                    self.log("Process completed and result retrieved")
+                    return result
+
+            # Poll the queue instead of blocking
+            try:
+                result = queue.get(timeout=1)
+            except Empty:
+                # No result yet, continue monitoring
+                continue
+            else:
+                self.log("Result received from worker process")
+                return result
+
+        # Overall timeout reached
+        msg = f"Process timed out after {timeout} seconds"
+        raise TimeoutError(msg)
+
+    def _terminate_process_gracefully(self, proc, timeout_terminate: int = 10, timeout_kill: int = 5):
+        """Terminate process gracefully with escalating signals.
+
+        First tries SIGTERM, then SIGKILL if needed.
+        """
+        if not proc.is_alive():
+            return
+
+        self.log("Attempting graceful process termination with SIGTERM")
+        proc.terminate()  # Send SIGTERM
+        proc.join(timeout=timeout_terminate)
+
+        if proc.is_alive():
+            self.log("Process didn't respond to SIGTERM, using SIGKILL")
+            proc.kill()  # Send SIGKILL
+            proc.join(timeout=timeout_kill)
+
+            if proc.is_alive():
+                self.log("Warning: Process still alive after SIGKILL")
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        try:
+            from docling.datamodel.base_models import InputFormat
+            from docling.datamodel.pipeline_options import OcrOptions, PdfPipelineOptions, VlmPipelineOptions
+            from docling.document_converter import DocumentConverter, FormatOption, PdfFormatOption
+            from docling.models.factories import get_ocr_factory
+            from docling.pipeline.vlm_pipeline import VlmPipeline
+        except ImportError as e:
+            msg = (
+                "Docling is an optional dependency. Install with `uv pip install 'langflow[docling]'` or refer to the "
+                "documentation on how to install optional dependencies."
+            )
+            raise ImportError(msg) from e
+
+        # Configure the standard PDF pipeline
+        def _get_standard_opts() -> PdfPipelineOptions:
+            pipeline_options = PdfPipelineOptions()
+            pipeline_options.do_ocr = self.ocr_engine != "None"
+            if pipeline_options.do_ocr:
+                ocr_factory = get_ocr_factory(
+                    allow_external_plugins=False,
+                )
+
+                ocr_options: OcrOptions = ocr_factory.create_options(
+                    kind=self.ocr_engine,
+                )
+                pipeline_options.ocr_options = ocr_options
+            return pipeline_options
+
+        # Configure the VLM pipeline
+        def _get_vlm_opts() -> VlmPipelineOptions:
+            return VlmPipelineOptions()
+
+        # Configure the main format options and create the DocumentConverter()
+        def _get_converter() -> DocumentConverter:
+            if self.pipeline == "standard":
+                pdf_format_option = PdfFormatOption(
+                    pipeline_options=_get_standard_opts(),
+                )
+            elif self.pipeline == "vlm":
+                pdf_format_option = PdfFormatOption(pipeline_cls=VlmPipeline, pipeline_options=_get_vlm_opts())
+
+            format_options: dict[InputFormat, FormatOption] = {
+                InputFormat.PDF: pdf_format_option,
+                InputFormat.IMAGE: pdf_format_option,
+            }
+
+            return DocumentConverter(format_options=format_options)
+
+        file_paths = [file.path for file in file_list if file.path]
+
+        if not file_paths:
+            self.log("No files to process.")
+            return file_list
+
+        ctx = get_context("spawn")
+        queue: Queue = ctx.Queue()
+        proc = ctx.Process(
+            target=docling_worker,
+            args=(file_paths, queue, self.pipeline, self.ocr_engine),
+        )
+
+        result = None
+        proc.start()
+
+        try:
+            result = self._wait_for_result_with_process_monitoring(queue, proc, timeout=300)
+        except KeyboardInterrupt:
+            self.log("Docling process cancelled by user")
+            result = []
+        except Exception as e:
+            self.log(f"Error during processing: {e}")
+            raise
+        finally:
+            # Improved cleanup with graceful termination
+            try:
+                self._terminate_process_gracefully(proc)
+            finally:
+                # Always close and cleanup queue resources
+                try:
+                    queue.close()
+                    queue.join_thread()
+                except Exception as e:  # noqa: BLE001
+                    # Ignore cleanup errors, but log them
+                    self.log(f"Warning: Error during queue cleanup - {e}")
+
+        # Check if there was an error in the worker
+        if isinstance(result, dict) and "error" in result:
+            msg = result["error"]
+            if msg.startswith("Docling is not installed"):
+                raise ImportError(msg)
+            # Handle interrupt gracefully - return empty result instead of raising error
+            if "Worker interrupted by SIGINT" in msg or "shutdown" in result:
+                self.log("Docling process cancelled by user")
+                result = []
+            else:
+                raise RuntimeError(msg)
+
+        processed_data = [Data(data={"doc": r["document"], "file_path": r["file_path"]}) if r else None for r in result]
+        return self.rollup_data(file_list, processed_data)

lfx/components/docling/docling_remote.py

@@ -0,0 +1,193 @@
+import base64
+import time
+from concurrent.futures import Future, ThreadPoolExecutor
+from pathlib import Path
+from typing import Any
+
+import httpx
+from docling_core.types.doc import DoclingDocument
+from pydantic import ValidationError
+
+from lfx.base.data import BaseFileComponent
+from lfx.inputs import IntInput, NestedDictInput, StrInput
+from lfx.inputs.inputs import FloatInput
+from lfx.schema import Data
+
+
+class DoclingRemoteComponent(BaseFileComponent):
+    display_name = "Docling Serve"
+    description = "Uses Docling to process input documents connecting to your instance of Docling Serve."
+    documentation = "https://docling-project.github.io/docling/"
+    trace_type = "tool"
+    icon = "Docling"
+    name = "DoclingRemote"
+
+    MAX_500_RETRIES = 5
+
+    # https://docling-project.github.io/docling/usage/supported_formats/
+    VALID_EXTENSIONS = [
+        "adoc",
+        "asciidoc",
+        "asc",
+        "bmp",
+        "csv",
+        "dotx",
+        "dotm",
+        "docm",
+        "docx",
+        "htm",
+        "html",
+        "jpeg",
+        "json",
+        "md",
+        "pdf",
+        "png",
+        "potx",
+        "ppsx",
+        "pptm",
+        "potm",
+        "ppsm",
+        "pptx",
+        "tiff",
+        "txt",
+        "xls",
+        "xlsx",
+        "xhtml",
+        "xml",
+        "webp",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        StrInput(
+            name="api_url",
+            display_name="Server address",
+            info="URL of the Docling Serve instance.",
+            required=True,
+        ),
+        IntInput(
+            name="max_concurrency",
+            display_name="Concurrency",
+            info="Maximum number of concurrent requests for the server.",
+            advanced=True,
+            value=2,
+        ),
+        FloatInput(
+            name="max_poll_timeout",
+            display_name="Maximum poll time",
+            info="Maximum waiting time for the document conversion to complete.",
+            advanced=True,
+            value=3600,
+        ),
+        NestedDictInput(
+            name="api_headers",
+            display_name="HTTP headers",
+            advanced=True,
+            required=False,
+            info=("Optional dictionary of additional headers required for connecting to Docling Serve."),
+        ),
+        NestedDictInput(
+            name="docling_serve_opts",
+            display_name="Docling options",
+            advanced=True,
+            required=False,
+            info=(
+                "Optional dictionary of additional options. "
+                "See https://github.com/docling-project/docling-serve/blob/main/docs/usage.md for more information."
+            ),
+        ),
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        base_url = f"{self.api_url}/v1alpha"
+
+        def _convert_document(client: httpx.Client, file_path: Path, options: dict[str, Any]) -> Data | None:
+            encoded_doc = base64.b64encode(file_path.read_bytes()).decode()
+            payload = {
+                "options": options,
+                "file_sources": [{"base64_string": encoded_doc, "filename": file_path.name}],
+            }
+
+            response = client.post(f"{base_url}/convert/source/async", json=payload)
+            response.raise_for_status()
+            task = response.json()
+
+            http_failures = 0
+            retry_status_start = 500
+            retry_status_end = 600
+            start_wait_time = time.monotonic()
+            while task["task_status"] not in ("success", "failure"):
+                # Check if processing exceeds the maximum poll timeout
+                processing_time = time.monotonic() - start_wait_time
+                if processing_time >= self.max_poll_timeout:
+                    msg = (
+                        f"Processing time {processing_time=} exceeds the maximum poll timeout {self.max_poll_timeout=}."
+                        "Please increase the max_poll_timeout parameter or review why the processing "
+                        "takes long on the server."
+                    )
+                    self.log(msg)
+                    raise RuntimeError(msg)
+
+                # Call for a new status update
+                time.sleep(2)
+                response = client.get(f"{base_url}/status/poll/{task['task_id']}")
+
+                # Check if the status call gets into 5xx errors and retry
+                if retry_status_start <= response.status_code < retry_status_end:
+                    http_failures += 1
+                    if http_failures > self.MAX_500_RETRIES:
+                        self.log(f"The status requests got a http response {response.status_code} too many times.")
+                        return None
+                    continue
+
+                # Update task status
+                task = response.json()
+
+            result_resp = client.get(f"{base_url}/result/{task['task_id']}")
+            result_resp.raise_for_status()
+            result = result_resp.json()
+
+            if "json_content" not in result["document"] or result["document"]["json_content"] is None:
+                self.log("No JSON DoclingDocument found in the result.")
+                return None
+
+            try:
+                doc = DoclingDocument.model_validate(result["document"]["json_content"])
+                return Data(data={"doc": doc, "file_path": str(file_path)})
+            except ValidationError as e:
+                self.log(f"Error validating the document. {e}")
+                return None
+
+        docling_options = {
+            "to_formats": ["json"],
+            "image_export_mode": "placeholder",
+            "return_as_file": False,
+            **(self.docling_serve_opts or {}),
+        }
+
+        processed_data: list[Data | None] = []
+        with (
+            httpx.Client(headers=self.api_headers) as client,
+            ThreadPoolExecutor(max_workers=self.max_concurrency) as executor,
+        ):
+            futures: list[tuple[int, Future]] = []
+            for i, file in enumerate(file_list):
+                if file.path is None:
+                    processed_data.append(None)
+                    continue
+
+                futures.append((i, executor.submit(_convert_document, client, file.path, docling_options)))
+
+            for _index, future in futures:
+                try:
+                    result_data = future.result()
+                    processed_data.append(result_data)
+                except (httpx.HTTPStatusError, httpx.RequestError, KeyError, ValueError) as exc:
+                    self.log(f"Docling remote processing failed: {exc}")
+                    raise
+
+        return self.rollup_data(file_list, processed_data)