lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/deepseek/deepseek.py

@@ -0,0 +1,136 @@
+import requests
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DictInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+
+DEEPSEEK_MODELS = ["deepseek-chat"]
+
+
+class DeepSeekModelComponent(LCModelComponent):
+    display_name = "DeepSeek"
+    description = "Generate text using DeepSeek LLMs."
+    icon = "DeepSeek"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="Maximum number of tokens to generate. Set to 0 for unlimited.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            info="DeepSeek model to use",
+            options=DEEPSEEK_MODELS,
+            value="deepseek-chat",
+            refresh_button=True,
+        ),
+        StrInput(
+            name="api_base",
+            display_name="DeepSeek API Base",
+            advanced=True,
+            info="Base URL for API requests. Defaults to https://api.deepseek.com",
+            value="https://api.deepseek.com",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="DeepSeek API Key",
+            info="The DeepSeek API Key",
+            advanced=False,
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            info="Controls randomness in responses",
+            value=1.0,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+    ]
+
+    def get_models(self) -> list[str]:
+        if not self.api_key:
+            return DEEPSEEK_MODELS
+
+        url = f"{self.api_base}/models"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"}
+
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            model_list = response.json()
+            return [model["id"] for model in model_list.get("data", [])]
+        except requests.RequestException as e:
+            self.status = f"Error fetching models: {e}"
+            return DEEPSEEK_MODELS
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name in {"api_key", "api_base", "model_name"}:
+            models = self.get_models()
+            build_config["model_name"]["options"] = models
+        return build_config
+
+    def build_model(self) -> LanguageModel:
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError as e:
+            msg = "langchain-openai not installed. Please install with `pip install langchain-openai`"
+            raise ImportError(msg) from e
+
+        api_key = SecretStr(self.api_key).get_secret_value() if self.api_key else None
+        output = ChatOpenAI(
+            model=self.model_name,
+            temperature=self.temperature if self.temperature is not None else 0.1,
+            max_tokens=self.max_tokens or None,
+            model_kwargs=self.model_kwargs or {},
+            base_url=self.api_base,
+            api_key=api_key,
+            streaming=self.stream if hasattr(self, "stream") else False,
+            seed=self.seed,
+        )
+
+        if self.json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    def _get_exception_message(self, e: Exception):
+        """Get message from DeepSeek API exception."""
+        try:
+            from openai import BadRequestError
+
+            if isinstance(e, BadRequestError):
+                message = e.body.get("message")
+                if message:
+                    return message
+        except ImportError:
+            pass
+        return None

lfx/components/docling/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .chunk_docling_document import ChunkDoclingDocumentComponent
+    from .docling_inline import DoclingInlineComponent
+    from .docling_remote import DoclingRemoteComponent
+    from .export_docling_document import ExportDoclingDocumentComponent
+
+_dynamic_imports = {
+    "ChunkDoclingDocumentComponent": "chunk_docling_document",
+    "DoclingInlineComponent": "docling_inline",
+    "DoclingRemoteComponent": "docling_remote",
+    "ExportDoclingDocumentComponent": "export_docling_document",
+}
+
+__all__ = [
+    "ChunkDoclingDocumentComponent",
+    "DoclingInlineComponent",
+    "DoclingRemoteComponent",
+    "ExportDoclingDocumentComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import docling components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

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,238 @@
+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 _serialize_pydantic_model, docling_worker
+from lfx.inputs import BoolInput, DropdownInput, HandleInput, StrInput
+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"],
+            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"],
+            value="None",
+        ),
+        BoolInput(
+            name="do_picture_classification",
+            display_name="Picture classification",
+            info="If enabled, the Docling pipeline will classify the pictures type.",
+            value=False,
+        ),
+        HandleInput(
+            name="pic_desc_llm",
+            display_name="Picture description LLM",
+            info="If connected, the model to use for running the picture description task.",
+            input_types=["LanguageModel"],
+            required=False,
+        ),
+        StrInput(
+            name="pic_desc_prompt",
+            display_name="Picture description prompt",
+            value="Describe the image in three sentences. Be concise and accurate.",
+            info="The user prompt to use when invoking the model.",
+            advanced=True,
+        ),
+        # 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.document_converter import DocumentConverter  # noqa: F401
+        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
+
+        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
+
+        pic_desc_config: dict | None = None
+        if self.pic_desc_llm is not None:
+            pic_desc_config = _serialize_pydantic_model(self.pic_desc_llm)
+
+        ctx = get_context("spawn")
+        queue: Queue = ctx.Queue()
+        proc = ctx.Process(
+            target=docling_worker,
+            kwargs={
+                "file_paths": file_paths,
+                "queue": queue,
+                "pipeline": self.pipeline,
+                "ocr_engine": self.ocr_engine,
+                "do_picture_classification": self.do_picture_classification,
+                "pic_desc_config": pic_desc_config,
+                "pic_desc_prompt": self.pic_desc_prompt,
+            },
+        )
+
+        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}")
+
+        # Enhanced error checking with dependency-specific handling
+        if isinstance(result, dict) and "error" in result:
+            error_msg = result["error"]
+
+            # Handle dependency errors specifically
+            if result.get("error_type") == "dependency_error":
+                dependency_name = result.get("dependency_name", "Unknown dependency")
+                install_command = result.get("install_command", "Please check documentation")
+
+                # Create a user-friendly error message
+                user_message = (
+                    f"Missing OCR dependency: {dependency_name}. "
+                    f"{install_command} "
+                    f"Alternatively, you can set OCR Engine to 'None' to disable OCR processing."
+                )
+                raise ImportError(user_message)
+
+            # Handle other specific errors
+            if error_msg.startswith("Docling is not installed"):
+                raise ImportError(error_msg)
+
+            # Handle graceful shutdown
+            if "Worker interrupted by SIGINT" in error_msg or "shutdown" in result:
+                self.log("Docling process cancelled by user")
+                result = []
+            else:
+                raise RuntimeError(error_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)