langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/base/data/docling_utils.py

@@ -1,245 +0,0 @@
-import signal
-import sys
-import traceback
-from contextlib import suppress
-
-from docling_core.types.doc import DoclingDocument
-from loguru import logger
-
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-
-
-def extract_docling_documents(data_inputs: Data | list[Data] | DataFrame, doc_key: str) -> list[DoclingDocument]:
-    documents: list[DoclingDocument] = []
-    if isinstance(data_inputs, DataFrame):
-        if not len(data_inputs):
-            msg = "DataFrame is empty"
-            raise TypeError(msg)
-
-        if doc_key not in data_inputs.columns:
-            msg = f"Column '{doc_key}' not found in DataFrame"
-            raise TypeError(msg)
-        try:
-            documents = data_inputs[doc_key].tolist()
-        except Exception as e:
-            msg = f"Error extracting DoclingDocument from DataFrame: {e}"
-            raise TypeError(msg) from e
-    else:
-        if not data_inputs:
-            msg = "No data inputs provided"
-            raise TypeError(msg)
-
-        if isinstance(data_inputs, Data):
-            if doc_key not in data_inputs.data:
-                msg = (
-                    f"'{doc_key}' field not available in the input Data. "
-                    "Check that your input is a DoclingDocument. "
-                    "You can use the Docling component to convert your input to a DoclingDocument."
-                )
-                raise TypeError(msg)
-            documents = [data_inputs.data[doc_key]]
-        else:
-            try:
-                documents = [
-                    input_.data[doc_key]
-                    for input_ in data_inputs
-                    if isinstance(input_, Data)
-                    and doc_key in input_.data
-                    and isinstance(input_.data[doc_key], DoclingDocument)
-                ]
-                if not documents:
-                    msg = f"No valid Data inputs found in {type(data_inputs)}"
-                    raise TypeError(msg)
-            except AttributeError as e:
-                msg = f"Invalid input type in collection: {e}"
-                raise TypeError(msg) from e
-    return documents
-
-
-def docling_worker(file_paths: list[str], queue, pipeline: str, ocr_engine: str):
-    """Worker function for processing files with Docling in a separate process."""
-    # Signal handling for graceful shutdown
-    shutdown_requested = False
-
-    def signal_handler(signum: int, frame) -> None:  # noqa: ARG001
-        """Handle shutdown signals gracefully."""
-        nonlocal shutdown_requested
-        signal_names: dict[int, str] = {signal.SIGTERM: "SIGTERM", signal.SIGINT: "SIGINT"}
-        signal_name = signal_names.get(signum, f"signal {signum}")
-
-        logger.debug(f"Docling worker received {signal_name}, initiating graceful shutdown...")
-        shutdown_requested = True
-
-        # Send shutdown notification to parent process
-        with suppress(Exception):
-            queue.put({"error": f"Worker interrupted by {signal_name}", "shutdown": True})
-
-        # Exit gracefully
-        sys.exit(0)
-
-    def check_shutdown() -> None:
-        """Check if shutdown was requested and exit if so."""
-        if shutdown_requested:
-            logger.info("Shutdown requested, exiting worker...")
-
-            with suppress(Exception):
-                queue.put({"error": "Worker shutdown requested", "shutdown": True})
-
-            sys.exit(0)
-
-    # Register signal handlers early
-    try:
-        signal.signal(signal.SIGTERM, signal_handler)
-        signal.signal(signal.SIGINT, signal_handler)
-        logger.debug("Signal handlers registered for graceful shutdown")
-    except (OSError, ValueError) as e:
-        # Some signals might not be available on all platforms
-        logger.warning(f"Warning: Could not register signal handlers: {e}")
-
-    # Check for shutdown before heavy imports
-    check_shutdown()
-
-    try:
-        from docling.datamodel.base_models import ConversionStatus, 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
-
-        # Check for shutdown after imports
-        check_shutdown()
-        logger.debug("Docling dependencies loaded successfully")
-
-    except ModuleNotFoundError:
-        msg = (
-            "Docling is an optional dependency of Langflow. "
-            "Install with `uv pip install 'langflow[docling]'` "
-            "or refer to the documentation"
-        )
-        queue.put({"error": msg})
-        return
-    except ImportError as e:
-        # A different import failed (e.g., a transitive dependency); preserve details.
-        queue.put({"error": f"Failed to import a Docling dependency: {e}"})
-        return
-    except KeyboardInterrupt:
-        logger.warning("KeyboardInterrupt during imports, exiting...")
-        queue.put({"error": "Worker interrupted during imports", "shutdown": True})
-        return
-
-    # Configure the standard PDF pipeline
-    def _get_standard_opts() -> PdfPipelineOptions:
-        check_shutdown()  # Check before heavy operations
-
-        pipeline_options = PdfPipelineOptions()
-        pipeline_options.do_ocr = ocr_engine != ""
-        if pipeline_options.do_ocr:
-            ocr_factory = get_ocr_factory(
-                allow_external_plugins=False,
-            )
-
-            ocr_options: OcrOptions = ocr_factory.create_options(
-                kind=ocr_engine,
-            )
-            pipeline_options.ocr_options = ocr_options
-        return pipeline_options
-
-    # Configure the VLM pipeline
-    def _get_vlm_opts() -> VlmPipelineOptions:
-        check_shutdown()  # Check before heavy operations
-        return VlmPipelineOptions()
-
-    # Configure the main format options and create the DocumentConverter()
-    def _get_converter() -> DocumentConverter:
-        check_shutdown()  # Check before heavy operations
-
-        if pipeline == "standard":
-            pdf_format_option = PdfFormatOption(
-                pipeline_options=_get_standard_opts(),
-            )
-        elif pipeline == "vlm":
-            pdf_format_option = PdfFormatOption(pipeline_cls=VlmPipeline, pipeline_options=_get_vlm_opts())
-        else:
-            msg = f"Unknown pipeline: {pipeline!r}"
-            raise ValueError(msg)
-
-        format_options: dict[InputFormat, FormatOption] = {
-            InputFormat.PDF: pdf_format_option,
-            InputFormat.IMAGE: pdf_format_option,
-        }
-
-        return DocumentConverter(format_options=format_options)
-
-    try:
-        # Check for shutdown before creating converter (can be slow)
-        check_shutdown()
-        logger.info(f"Initializing {pipeline} pipeline with OCR: {ocr_engine or 'disabled'}")
-
-        converter = _get_converter()
-
-        # Check for shutdown before processing files
-        check_shutdown()
-        logger.info(f"Starting to process {len(file_paths)} files...")
-
-        # Process files with periodic shutdown checks
-        results = []
-        for i, file_path in enumerate(file_paths):
-            # Check for shutdown before processing each file
-            check_shutdown()
-
-            logger.debug(f"Processing file {i + 1}/{len(file_paths)}: {file_path}")
-
-            try:
-                # Process single file (we can't easily interrupt convert_all)
-                single_result = converter.convert_all([file_path])
-                results.extend(single_result)
-
-                # Check for shutdown after each file
-                check_shutdown()
-
-            except (OSError, ValueError, RuntimeError, ImportError) as file_error:
-                # Handle specific file processing errors
-                logger.error(f"Error processing file {file_path}: {file_error}")
-                # Continue with other files, but check for shutdown
-                check_shutdown()
-            except Exception as file_error:  # noqa: BLE001
-                # Catch any other unexpected errors to prevent worker crash
-                logger.error(f"Unexpected error processing file {file_path}: {file_error}")
-                # Continue with other files, but check for shutdown
-                check_shutdown()
-
-        # Final shutdown check before sending results
-        check_shutdown()
-
-        # Process the results while maintaining the original structure
-        processed_data = [
-            {"document": res.document, "file_path": str(res.input.file), "status": res.status.name}
-            if res.status == ConversionStatus.SUCCESS
-            else None
-            for res in results
-        ]
-
-        logger.info(f"Successfully processed {len([d for d in processed_data if d])} files")
-        queue.put(processed_data)
-
-    except KeyboardInterrupt:
-        logger.warning("KeyboardInterrupt during processing, exiting gracefully...")
-        queue.put({"error": "Worker interrupted during processing", "shutdown": True})
-        return
-    except Exception as e:  # noqa: BLE001
-        if shutdown_requested:
-            logger.exception("Exception occurred during shutdown, exiting...")
-            return
-
-        # Send any processing error to the main process with traceback
-        error_info = {"error": str(e), "traceback": traceback.format_exc()}
-        logger.error(f"Error in worker: {error_info}")
-        queue.put(error_info)
-    finally:
-        logger.info("Docling worker finishing...")
-        # Ensure we don't leave any hanging processes
-        if shutdown_requested:
-            logger.debug("Worker shutdown completed")
-        else:
-            logger.debug("Worker completed normally")

langflow/base/document_transformers/model.py

@@ -1,43 +0,0 @@
-from abc import abstractmethod
-from typing import Any
-
-from langchain_core.documents import BaseDocumentTransformer
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.utils.util import build_loader_repr_from_data
-
-
-class LCDocumentTransformerComponent(Component):
-    trace_type = "document_transformer"
-    outputs = [
-        Output(display_name="Data", name="data", method="transform_data"),
-    ]
-
-    def transform_data(self) -> list[Data]:
-        data_input = self.get_data_input()
-        documents = []
-
-        if not isinstance(data_input, list):
-            data_input = [data_input]
-
-        for _input in data_input:
-            if isinstance(_input, Data):
-                documents.append(_input.to_lc_document())
-            else:
-                documents.append(_input)
-
-        transformer = self.build_document_transformer()
-        docs = transformer.transform_documents(documents)
-        data = self.to_data(docs)
-        self.repr_value = build_loader_repr_from_data(data)
-        return data
-
-    @abstractmethod
-    def get_data_input(self) -> Any:
-        """Get the data input."""
-
-    @abstractmethod
-    def build_document_transformer(self) -> BaseDocumentTransformer:
-        """Build the text splitter."""

langflow/base/embeddings/aiml_embeddings.py

@@ -1,62 +0,0 @@
-import concurrent.futures
-import json
-
-import httpx
-from pydantic import BaseModel, SecretStr
-
-from langflow.field_typing import Embeddings
-from langflow.logging.logger import logger
-
-
-class AIMLEmbeddingsImpl(BaseModel, Embeddings):
-    embeddings_completion_url: str = "https://api.aimlapi.com/v1/embeddings"
-
-    api_key: SecretStr
-    model: str
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        embeddings = [None] * len(texts)
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key.get_secret_value()}",
-        }
-
-        with httpx.Client() as client, concurrent.futures.ThreadPoolExecutor() as executor:
-            futures = []
-            for i, text in enumerate(texts):
-                futures.append((i, executor.submit(self._embed_text, client, headers, text)))
-
-            for index, future in futures:
-                try:
-                    result_data = future.result()
-                    if len(result_data["data"]) != 1:
-                        msg = f"Expected one embedding, got {len(result_data['data'])}"
-                        raise ValueError(msg)
-                    embeddings[index] = result_data["data"][0]["embedding"]
-                except (
-                    httpx.HTTPStatusError,
-                    httpx.RequestError,
-                    json.JSONDecodeError,
-                    KeyError,
-                    ValueError,
-                ):
-                    logger.exception("Error occurred")
-                    raise
-
-        return embeddings  # type: ignore[return-value]
-
-    def _embed_text(self, client: httpx.Client, headers: dict, text: str) -> dict:
-        payload = {
-            "model": self.model,
-            "input": text,
-        }
-        response = client.post(
-            self.embeddings_completion_url,
-            headers=headers,
-            json=payload,
-        )
-        response.raise_for_status()
-        return response.json()
-
-    def embed_query(self, text: str) -> list[float]:
-        return self.embed_documents([text])[0]

langflow/base/embeddings/model.py

@@ -1,26 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Embeddings
-from langflow.io import Output
-
-
-class LCEmbeddingsModel(Component):
-    trace_type = "embedding"
-
-    outputs = [
-        Output(display_name="Embedding Model", name="embeddings", method="build_embeddings"),
-    ]
-
-    def _validate_outputs(self) -> None:
-        required_output_methods = ["build_embeddings"]
-        output_names = [output.name for output in self.outputs]
-        for method_name in required_output_methods:
-            if method_name not in output_names:
-                msg = f"Output with name '{method_name}' must be defined."
-                raise ValueError(msg)
-            if not hasattr(self, method_name):
-                msg = f"Method '{method_name}' must be defined."
-                raise ValueError(msg)
-
-    def build_embeddings(self) -> Embeddings:
-        msg = "You must implement the build_embeddings method in your class."
-        raise NotImplementedError(msg)

langflow/base/flow_processing/utils.py

@@ -1,86 +0,0 @@
-from langflow.graph.schema import ResultData, RunOutputs
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-def build_data_from_run_outputs(run_outputs: RunOutputs) -> list[Data]:
-    """Build a list of data from the given RunOutputs.
-
-    Args:
-        run_outputs (RunOutputs): The RunOutputs object containing the output data.
-
-    Returns:
-        List[Data]: A list of data built from the RunOutputs.
-
-    """
-    if not run_outputs:
-        return []
-    data = []
-    for result_data in run_outputs.outputs:
-        if result_data:
-            data.extend(build_data_from_result_data(result_data))
-    return data
-
-
-def build_data_from_result_data(result_data: ResultData) -> list[Data]:
-    """Build a list of data from the given ResultData.
-
-    Args:
-        result_data (ResultData): The ResultData object containing the result data.
-
-    Returns:
-        List[Data]: A list of data built from the ResultData.
-
-    """
-    messages = result_data.messages
-
-    if not messages:
-        return []
-    data = []
-
-    # Handle results without chat messages (calling flow)
-    if not messages:
-        # Result with a single record
-        if isinstance(result_data.artifacts, dict):
-            data.append(Data(data=result_data.artifacts))
-        # List of artifacts
-        elif isinstance(result_data.artifacts, list):
-            for artifact in result_data.artifacts:
-                # If multiple records are found as artifacts, return as-is
-                if isinstance(artifact, Data):
-                    data.append(artifact)
-                else:
-                    # Warn about unknown output type
-                    logger.warning(f"Unable to build record output from unknown ResultData.artifact: {artifact}")
-        # Chat or text output
-        elif result_data.results:
-            data.append(Data(data={"result": result_data.results}, text_key="result"))
-            return data
-        else:
-            return []
-
-    if isinstance(result_data.results, dict):
-        for name, result in result_data.results.items():
-            dataobj: Data | Message | None
-            dataobj = result if isinstance(result, Message) else Data(data=result, text_key=name)
-
-            data.append(dataobj)
-    else:
-        data.append(Data(data=result_data.results))
-    return data
-
-
-def format_flow_output_data(data: list[Data]) -> str:
-    """Format the flow output data into a string.
-
-    Args:
-        data (List[Data]): The list of data to format.
-
-    Returns:
-        str: The formatted flow output data.
-
-    """
-    result = "Flow run output:\n"
-    results = "\n".join([value.get_text() if hasattr(value, "get_text") else str(value) for value in data])
-    return result + results

langflow/base/huggingface/model_bridge.py

@@ -1,133 +0,0 @@
-# Import LangChain base
-from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolCall
-from langchain_core.tools import BaseTool
-
-# Import Hugging Face Model base
-from smolagents import Model, Tool
-from smolagents.models import ChatMessage, ChatMessageToolCall, ChatMessageToolCallDefinition
-
-
-def _lc_tool_call_to_hf_tool_call(tool_call: ToolCall) -> ChatMessageToolCall:
-    """Convert a LangChain ToolCall to a Hugging Face ChatMessageToolCall.
-
-    Args:
-        tool_call (ToolCall): LangChain tool call to convert
-
-    Returns:
-        ChatMessageToolCall: Equivalent Hugging Face tool call
-    """
-    return ChatMessageToolCall(
-        function=ChatMessageToolCallDefinition(name=tool_call.name, arguments=tool_call.args),
-        id=tool_call.id,
-    )
-
-
-def _hf_tool_to_lc_tool(tool) -> BaseTool:
-    """Convert a Hugging Face Tool to a LangChain BaseTool.
-
-    Args:
-        tool (Tool): Hugging Face tool to convert
-
-    Returns:
-        BaseTool: Equivalent LangChain tool
-    """
-    if not hasattr(tool, "langchain_tool"):
-        msg = "Hugging Face Tool does not have a langchain_tool attribute"
-        raise ValueError(msg)
-    return tool.langchain_tool
-
-
-class LangChainHFModel(Model):
-    """A class bridging Hugging Face's `Model` interface with a LangChain `BaseChatModel`.
-
-    This adapter allows using any LangChain chat model with the Hugging Face interface.
-    It handles conversion of message formats and tool calls between the two frameworks.
-
-    Usage:
-       >>> lc_model = LangChainChatModel(...)  # any BaseChatModel
-       >>> hf_model = LangChainHFModel(lc_model)
-       >>> hf_model(messages=[{"role": "user", "content": "Hello!"}])
-    """
-
-    def __init__(self, chat_model: BaseChatModel, **kwargs):
-        """Initialize the bridge model.
-
-        Args:
-            chat_model (BaseChatModel): LangChain chat model to wrap
-            **kwargs: Additional arguments passed to Model.__init__
-        """
-        super().__init__(**kwargs)
-        self.chat_model = chat_model
-
-    def __call__(
-        self,
-        messages: list[dict[str, str]],
-        stop_sequences: list[str] | None = None,
-        grammar: str | None = None,
-        tools_to_call_from: list[Tool] | None = None,
-        **kwargs,
-    ) -> ChatMessage:
-        """Process messages through the LangChain model and return Hugging Face format.
-
-        Args:
-            messages: List of message dictionaries with 'role' and 'content' keys
-            stop_sequences: Optional list of strings to stop generation
-            grammar: Optional grammar specification (not used)
-            tools_to_call_from: Optional list of available tools (not used)
-            **kwargs: Additional arguments passed to the LangChain model
-
-        Returns:
-            ChatMessage: Response in Hugging Face format
-        """
-        if grammar:
-            msg = "Grammar is not yet supported."
-            raise ValueError(msg)
-
-        # Convert HF messages to LangChain messages
-        lc_messages = []
-        for m in messages:
-            role = m["role"]
-            content = m["content"]
-            if role == "system":
-                lc_messages.append(SystemMessage(content=content))
-            elif role == "assistant":
-                lc_messages.append(AIMessage(content=content))
-            else:
-                # Default any unknown role to "user"
-                lc_messages.append(HumanMessage(content=content))
-
-        # Convert tools to LangChain tools
-        if tools_to_call_from:
-            tools_to_call_from = [_hf_tool_to_lc_tool(tool) for tool in tools_to_call_from]
-
-        model = self.chat_model.bind_tools(tools_to_call_from) if tools_to_call_from else self.chat_model
-
-        # Call the LangChain model
-        result_msg: AIMessage = model.invoke(lc_messages, stop=stop_sequences, **kwargs)
-
-        # Convert the AIMessage into an HF ChatMessage
-        return ChatMessage(
-            role="assistant",
-            content=result_msg.content or "",
-            tool_calls=[_lc_tool_call_to_hf_tool_call(tool_call) for tool_call in result_msg.tool_calls],
-        )
-
-
-# How to use
-# if __name__ == "__main__":
-#     from langchain_community.tools import DuckDuckGoSearchRun
-#     from langchain_openai import ChatOpenAI
-#     from rich import rprint
-#     from smolagents import CodeAgent
-
-#     # Example usage
-#     model = LangChainHFModel(chat_model=ChatOpenAI(model="gpt-4o-mini"))
-#     search_tool = DuckDuckGoSearchRun()
-#     hf_tool = Tool.from_langchain(search_tool)
-
-#     code_agent = CodeAgent(
-#         model=model,
-#         tools=[hf_tool],
-#     )
-#     rprint(code_agent.run("Search for Langflow on DuckDuckGo and return the first result"))

langflow/base/langchain_utilities/model.py

@@ -1,35 +0,0 @@
-from abc import abstractmethod
-from collections.abc import Sequence
-
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Tool
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-
-
-class LCToolComponent(Component):
-    trace_type = "tool"
-    outputs = [
-        Output(name="api_run_model", display_name="Data", method="run_model"),
-        Output(name="api_build_tool", display_name="Tool", method="build_tool"),
-    ]
-
-    def _validate_outputs(self) -> None:
-        required_output_methods = ["run_model", "build_tool"]
-        output_names = [output.name for output in self.outputs]
-        for method_name in required_output_methods:
-            if method_name not in output_names:
-                msg = f"Output with name '{method_name}' must be defined."
-                raise ValueError(msg)
-            if not hasattr(self, method_name):
-                msg = f"Method '{method_name}' must be defined."
-                raise ValueError(msg)
-
-    @abstractmethod
-    def run_model(self) -> Data | list[Data] | DataFrame:
-        """Run model and return the output."""
-
-    @abstractmethod
-    def build_tool(self) -> Tool | Sequence[Tool]:
-        """Build the tool."""

langflow/base/langchain_utilities/spider_constants.py

@@ -1 +0,0 @@
-MODES = ["scrape", "crawl"]

langflow/base/langwatch/utils.py

@@ -1,18 +0,0 @@
-from functools import lru_cache
-from typing import Any
-
-import httpx
-
-from langflow.logging.logger import logger
-
-
-@lru_cache(maxsize=1)
-def get_cached_evaluators(url: str) -> dict[str, Any]:
-    try:
-        response = httpx.get(url, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        return data.get("evaluators", {})
-    except httpx.RequestError as e:
-        logger.error(f"Error fetching evaluators: {e}")
-        return {}

langflow/base/mcp/constants.py

@@ -1,2 +0,0 @@
-MAX_MCP_SERVER_NAME_LENGTH = 30
-MAX_MCP_TOOL_NAME_LENGTH = 30