lfx-nightly 0.1.12.dev0__py3-none-any.whl → 0.1.12.dev2__py3-none-any.whl

lfx/base/data/docling_utils.py

@@ -1,14 +1,20 @@
+import importlib
 import signal
 import sys
 import traceback
 from contextlib import suppress
+from typing import TYPE_CHECKING
 
 from docling_core.types.doc import DoclingDocument
+from pydantic import BaseModel, SecretStr, TypeAdapter
 
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 
+if TYPE_CHECKING:
+    from langchain_core.language_models.chat_models import BaseChatModel
+
 
 def extract_docling_documents(data_inputs: Data | list[Data] | DataFrame, doc_key: str) -> list[DoclingDocument]:
     documents: list[DoclingDocument] = []
@@ -57,7 +63,45 @@ def extract_docling_documents(data_inputs: Data | list[Data] | DataFrame, doc_ke
     return documents
 
 
-def docling_worker(file_paths: list[str], queue, pipeline: str, ocr_engine: str):
+def _unwrap_secrets(obj):
+    if isinstance(obj, SecretStr):
+        return obj.get_secret_value()
+    if isinstance(obj, dict):
+        return {k: _unwrap_secrets(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_unwrap_secrets(v) for v in obj]
+    return obj
+
+
+def _dump_with_secrets(model: BaseModel):
+    return _unwrap_secrets(model.model_dump(mode="python", round_trip=True))
+
+
+def _serialize_pydantic_model(model: BaseModel):
+    return {
+        "__class_path__": f"{model.__class__.__module__}.{model.__class__.__name__}",
+        "config": _dump_with_secrets(model),
+    }
+
+
+def _deserialize_pydantic_model(data: dict):
+    module_name, class_name = data["__class_path__"].rsplit(".", 1)
+    module = importlib.import_module(module_name)
+    cls = getattr(module, class_name)
+    adapter = TypeAdapter(cls)
+    return adapter.validate_python(data["config"])
+
+
+def docling_worker(
+    *,
+    file_paths: list[str],
+    queue,
+    pipeline: str,
+    ocr_engine: str,
+    do_picture_classification: bool,
+    pic_desc_config: dict | None,
+    pic_desc_prompt: str,
+):
     """Worker function for processing files with Docling in a separate process."""
     # Signal handling for graceful shutdown
     shutdown_requested = False
@@ -106,6 +150,7 @@ def docling_worker(file_paths: list[str], queue, pipeline: str, ocr_engine: str)
         from docling.document_converter import DocumentConverter, FormatOption, PdfFormatOption
         from docling.models.factories import get_ocr_factory
         from docling.pipeline.vlm_pipeline import VlmPipeline
+        from langchain_docling.picture_description import PictureDescriptionLangChainOptions
 
         # Check for shutdown after imports
         check_shutdown()
@@ -143,6 +188,19 @@ def docling_worker(file_paths: list[str], queue, pipeline: str, ocr_engine: str)
                 kind=ocr_engine,
             )
             pipeline_options.ocr_options = ocr_options
+
+        pipeline_options.do_picture_classification = do_picture_classification
+
+        if pic_desc_config:
+            pic_desc_llm: BaseChatModel = _deserialize_pydantic_model(pic_desc_config)
+
+            logger.info("Docling enabling the picture description stage.")
+            pipeline_options.do_picture_description = True
+            pipeline_options.allow_external_plugins = True
+            pipeline_options.picture_description_options = PictureDescriptionLangChainOptions(
+                llm=pic_desc_llm,
+                prompt=pic_desc_prompt,
+            )
         return pipeline_options
 
     # Configure the VLM pipeline

lfx/components/docling/docling_inline.py

@@ -3,8 +3,8 @@ 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.base.data.docling_utils import _serialize_pydantic_model, docling_worker
+from lfx.inputs import BoolInput, DropdownInput, HandleInput, StrInput
 from lfx.schema import Data
 
 
@@ -67,6 +67,26 @@ class DoclingInlineComponent(BaseFileComponent):
             real_time_refresh=False,
             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
     ]
 
@@ -131,11 +151,7 @@ class DoclingInlineComponent(BaseFileComponent):
 
     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
+            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 "
@@ -143,52 +159,29 @@ class DoclingInlineComponent(BaseFileComponent):
             )
             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
 
+        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,
-            args=(file_paths, queue, self.pipeline, self.ocr_engine),
+            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

lfx/components/logic/llm_conditional_router.py

@@ -0,0 +1,377 @@
+from typing import Any
+
+from langflow.custom import Component
+from langflow.io import BoolInput, HandleInput, MessageInput, MessageTextInput, MultilineInput, Output, TableInput
+from langflow.schema.message import Message
+
+
+class SmartRouterComponent(Component):
+    display_name = "Smart Router"
+    description = "Routes an input message using LLM-based categorization."
+    icon = "equal"
+    name = "SmartRouter"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._matched_category = None
+
+    inputs = [
+        HandleInput(
+            name="llm",
+            display_name="Language Model",
+            info="LLM to use for categorization.",
+            input_types=["LanguageModel"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="input_text",
+            display_name="Input",
+            info="The primary text input for the operation.",
+            required=True,
+        ),
+        TableInput(
+            name="routes",
+            display_name="Routes",
+            info=(
+                "Define the categories for routing. Each row should have a route/category name "
+                "and optionally a custom output value."
+            ),
+            table_schema=[
+                {
+                    "name": "route_category",
+                    "display_name": "Route/Category",
+                    "type": "str",
+                    "description": "Name for the route/category (used for both output name and category matching)",
+                },
+                {
+                    "name": "output_value",
+                    "display_name": "Output Value",
+                    "type": "str",
+                    "description": "Custom message for this category (overrides default output message if filled)",
+                    "default": "",
+                },
+            ],
+            value=[
+                {"route_category": "Positive", "output_value": ""},
+                {"route_category": "Negative", "output_value": ""},
+            ],
+            real_time_refresh=True,
+            required=True,
+        ),
+        MessageInput(
+            name="message",
+            display_name="Override Output",
+            info=(
+                "Optional override message that will replace both the Input and Output Value "
+                "for all routes when filled."
+            ),
+            required=False,
+            advanced=True,
+        ),
+        BoolInput(
+            name="enable_else_output",
+            display_name="Include Else Output",
+            info="Include an Else output for cases that don't match any route.",
+            value=False,
+            advanced=True,
+        ),
+        MultilineInput(
+            name="custom_prompt",
+            display_name="Additional Instructions",
+            info=(
+                "Additional instructions for LLM-based categorization. "
+                "These will be added to the base prompt. "
+                "Use {input_text} for the input text and {routes} for the available categories."
+            ),
+            advanced=True,
+        ),
+    ]
+
+    outputs: list[Output] = []
+
+    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
+        """Create a dynamic output for each category in the categories table."""
+        if field_name in {"routes", "enable_else_output"}:
+            frontend_node["outputs"] = []
+
+            # Get the routes data - either from field_value (if routes field) or from component state
+            routes_data = field_value if field_name == "routes" else getattr(self, "routes", [])
+
+            # Add a dynamic output for each category - all using the same method
+            for i, row in enumerate(routes_data):
+                route_category = row.get("route_category", f"Category {i + 1}")
+                frontend_node["outputs"].append(
+                    Output(
+                        display_name=route_category,
+                        name=f"category_{i + 1}_result",
+                        method="process_case",
+                        group_outputs=True,
+                    )
+                )
+            # Add default output only if enabled
+            if field_name == "enable_else_output":
+                enable_else = field_value
+            else:
+                enable_else = getattr(self, "enable_else_output", False)
+
+            if enable_else:
+                frontend_node["outputs"].append(
+                    Output(display_name="Else", name="default_result", method="default_response", group_outputs=True)
+                )
+        return frontend_node
+
+    def process_case(self) -> Message:
+        """Process all categories using LLM categorization and return message for matching category."""
+        # Clear any previous match state
+        self._matched_category = None
+
+        categories = getattr(self, "routes", [])
+        input_text = getattr(self, "input_text", "")
+
+        # Find the matching category using LLM-based categorization
+        matched_category = None
+        llm = getattr(self, "llm", None)
+
+        if llm and categories:
+            # Create prompt for categorization
+            category_values = [
+                category.get("route_category", f"Category {i + 1}") for i, category in enumerate(categories)
+            ]
+            categories_text = ", ".join([f'"{cat}"' for cat in category_values if cat])
+
+            # Create base prompt
+            base_prompt = (
+                f"You are a text classifier. Given the following text and categories, "
+                f"determine which category best matches the text.\n\n"
+                f'Text to classify: "{input_text}"\n\n'
+                f"Available categories: {categories_text}\n\n"
+                f"Respond with ONLY the exact category name that best matches the text. "
+                f'If none match well, respond with "NONE".\n\n'
+                f"Category:"
+            )
+
+            # Use custom prompt as additional instructions if provided
+            custom_prompt = getattr(self, "custom_prompt", "")
+            if custom_prompt and custom_prompt.strip():
+                self.status = "Using custom prompt as additional instructions"
+                # Format custom prompt with variables
+                formatted_custom = custom_prompt.format(input_text=input_text, routes=categories_text)
+                # Combine base prompt with custom instructions
+                prompt = f"{base_prompt}\n\nAdditional Instructions:\n{formatted_custom}"
+            else:
+                self.status = "Using default prompt for LLM categorization"
+                prompt = base_prompt
+
+            # Log the final prompt being sent to LLM
+            self.status = f"Prompt sent to LLM:\n{prompt}"
+
+            try:
+                # Use the LLM to categorize
+                if hasattr(llm, "invoke"):
+                    response = llm.invoke(prompt)
+                    if hasattr(response, "content"):
+                        categorization = response.content.strip().strip('"')
+                    else:
+                        categorization = str(response).strip().strip('"')
+                else:
+                    categorization = str(llm(prompt)).strip().strip('"')
+
+                # Log the categorization process
+                self.status = f"LLM response: '{categorization}'"
+
+                # Find matching category based on LLM response
+                for i, category in enumerate(categories):
+                    route_category = category.get("route_category", "")
+
+                    # Log each comparison attempt
+                    self.status = (
+                        f"Comparing '{categorization}' with category {i + 1}: route_category='{route_category}'"
+                    )
+
+                    if categorization.lower() == route_category.lower():
+                        matched_category = i
+                        self.status = f"MATCH FOUND! Category {i + 1} matched with '{categorization}'"
+                        break
+
+                if matched_category is None:
+                    self.status = (
+                        f"No match found for '{categorization}'. Available categories: "
+                        f"{[category.get('route_category', '') for category in categories]}"
+                    )
+
+            except RuntimeError as e:
+                self.status = f"Error in LLM categorization: {e!s}"
+        else:
+            self.status = "No LLM provided for categorization"
+
+        if matched_category is not None:
+            # Store the matched category for other outputs to check
+            self._matched_category = matched_category
+
+            # Stop all category outputs except the matched one
+            for i in range(len(categories)):
+                if i != matched_category:
+                    self.stop(f"category_{i + 1}_result")
+
+            # Also stop the default output (if it exists)
+            enable_else = getattr(self, "enable_else_output", False)
+            if enable_else:
+                self.stop("default_result")
+
+            route_category = categories[matched_category].get("route_category", f"Category {matched_category + 1}")
+            self.status = f"Categorized as {route_category}"
+
+            # Check if there's an override output (takes precedence over everything)
+            override_output = getattr(self, "message", None)
+            if (
+                override_output
+                and hasattr(override_output, "text")
+                and override_output.text
+                and str(override_output.text).strip()
+            ):
+                return Message(text=str(override_output.text))
+            if override_output and isinstance(override_output, str) and override_output.strip():
+                return Message(text=str(override_output))
+
+            # Check if there's a custom output value for this category
+            custom_output = categories[matched_category].get("output_value", "")
+            # Treat None, empty string, or whitespace as blank
+            if custom_output and str(custom_output).strip() and str(custom_output).strip().lower() != "none":
+                # Use custom output value
+                return Message(text=str(custom_output))
+            # Use input as default output
+            return Message(text=input_text)
+        # No match found, stop all category outputs
+        for i in range(len(categories)):
+            self.stop(f"category_{i + 1}_result")
+
+        # Check if else output is enabled
+        enable_else = getattr(self, "enable_else_output", False)
+        if enable_else:
+            # The default_response will handle the else case
+            self.stop("process_case")
+            return Message(text="")
+        # No else output, so no output at all
+        self.status = "No match found and Else output is disabled"
+        return Message(text="")
+
+    def default_response(self) -> Message:
+        """Handle the else case when no conditions match."""
+        # Check if else output is enabled
+        enable_else = getattr(self, "enable_else_output", False)
+        if not enable_else:
+            self.status = "Else output is disabled"
+            return Message(text="")
+
+        # Clear any previous match state if not already set
+        if not hasattr(self, "_matched_category"):
+            self._matched_category = None
+
+        categories = getattr(self, "routes", [])
+        input_text = getattr(self, "input_text", "")
+
+        # Check if a match was already found in process_case
+        if hasattr(self, "_matched_category") and self._matched_category is not None:
+            self.status = (
+                f"Match already found in process_case (Category {self._matched_category + 1}), "
+                "stopping default_response"
+            )
+            self.stop("default_result")
+            return Message(text="")
+
+        # Check if any category matches using LLM categorization
+        has_match = False
+        llm = getattr(self, "llm", None)
+
+        if llm and categories:
+            try:
+                # Create prompt for categorization
+                category_values = [
+                    category.get("route_category", f"Category {i + 1}") for i, category in enumerate(categories)
+                ]
+                categories_text = ", ".join([f'"{cat}"' for cat in category_values if cat])
+
+                # Create base prompt
+                base_prompt = (
+                    "You are a text classifier. Given the following text and categories, "
+                    "determine which category best matches the text.\n\n"
+                    f'Text to classify: "{input_text}"\n\n'
+                    f"Available categories: {categories_text}\n\n"
+                    "Respond with ONLY the exact category name that best matches the text. "
+                    'If none match well, respond with "NONE".\n\n'
+                    "Category:"
+                )
+
+                # Use custom prompt as additional instructions if provided
+                custom_prompt = getattr(self, "custom_prompt", "")
+                if custom_prompt and custom_prompt.strip():
+                    self.status = "Using custom prompt as additional instructions (default check)"
+                    # Format custom prompt with variables
+                    formatted_custom = custom_prompt.format(input_text=input_text, routes=categories_text)
+                    # Combine base prompt with custom instructions
+                    prompt = f"{base_prompt}\n\nAdditional Instructions:\n{formatted_custom}"
+                else:
+                    self.status = "Using default prompt for LLM categorization (default check)"
+                    prompt = base_prompt
+
+                # Log the final prompt being sent to LLM for default check
+                self.status = f"Default check - Prompt sent to LLM:\n{prompt}"
+
+                # Use the LLM to categorize
+                if hasattr(llm, "invoke"):
+                    response = llm.invoke(prompt)
+                    if hasattr(response, "content"):
+                        categorization = response.content.strip().strip('"')
+                    else:
+                        categorization = str(response).strip().strip('"')
+                else:
+                    categorization = str(llm(prompt)).strip().strip('"')
+
+                # Log the categorization process for default check
+                self.status = f"Default check - LLM response: '{categorization}'"
+
+                # Check if LLM response matches any category
+                for i, category in enumerate(categories):
+                    route_category = category.get("route_category", "")
+
+                    # Log each comparison attempt
+                    self.status = (
+                        f"Default check - Comparing '{categorization}' with category {i + 1}: "
+                        f"route_category='{route_category}'"
+                    )
+
+                    if categorization.lower() == route_category.lower():
+                        has_match = True
+                        self.status = f"Default check - MATCH FOUND! Category {i + 1} matched with '{categorization}'"
+                        break
+
+                if not has_match:
+                    self.status = (
+                        f"Default check - No match found for '{categorization}'. "
+                        f"Available categories: "
+                        f"{[category.get('route_category', '') for category in categories]}"
+                    )
+
+            except RuntimeError:
+                pass  # If there's an error, treat as no match
+
+        if has_match:
+            # A case matches, stop this output
+            self.stop("default_result")
+            return Message(text="")
+
+        # No case matches, check for override output first, then use input as default
+        override_output = getattr(self, "message", None)
+        if (
+            override_output
+            and hasattr(override_output, "text")
+            and override_output.text
+            and str(override_output.text).strip()
+        ):
+            self.status = "Routed to Else (no match) - using override output"
+            return Message(text=str(override_output.text))
+        if override_output and isinstance(override_output, str) and override_output.strip():
+            self.status = "Routed to Else (no match) - using override output"
+            return Message(text=str(override_output))
+        self.status = "Routed to Else (no match) - using input as default"
+        return Message(text=input_text)

lfx/components/processing/data_operations.py

@@ -1,9 +1,13 @@
 import ast
+import json
 from typing import TYPE_CHECKING, Any
 
+import jq
+from json_repair import repair_json
+
 from lfx.custom import Component
 from lfx.inputs import DictInput, DropdownInput, MessageTextInput, SortableListInput
-from lfx.io import DataInput, Output
+from lfx.io import DataInput, MultilineInput, Output
 from lfx.log.logger import logger
 from lfx.schema import Data
 from lfx.schema.dotdict import dotdict
@@ -20,6 +24,8 @@ ACTION_CONFIG = {
     "Append or Update": {"is_list": False, "log_msg": "setting Append or Update fields"},
     "Remove Keys": {"is_list": False, "log_msg": "setting remove keys fields"},
     "Rename Keys": {"is_list": False, "log_msg": "setting rename keys fields"},
+    "Path Selection": {"is_list": False, "log_msg": "setting mapped key extractor fields"},
+    "JQ Expression": {"is_list": False, "log_msg": "setting parse json fields"},
 }
 OPERATORS = {
     "equals": lambda a, b: str(a) == str(b),
@@ -33,7 +39,6 @@ OPERATORS = {
 class DataOperationsComponent(Component):
     display_name = "Data Operations"
     description = "Perform various operations on a Data object."
-    documentation: str = "https://docs.langflow.org/components-processing#data-operations"
     icon = "file-json"
     name = "DataOperations"
     default_keys = ["operations", "data"]
@@ -59,6 +64,9 @@ class DataOperationsComponent(Component):
             "data filtering",
             "data selection",
             "data combination",
+            "Parse JSON",
+            "JSON Query",
+            "JQ Query",
         ],
     }
     actions_data = {
@@ -69,8 +77,47 @@ class DataOperationsComponent(Component):
         "Append or Update": ["append_update_data", "operations"],
         "Remove Keys": ["remove_keys_input", "operations"],
         "Rename Keys": ["rename_keys_input", "operations"],
+        "Path Selection": ["mapped_json_display", "selected_key", "operations"],
+        "JQ Expression": ["query", "operations"],
     }
 
+    @staticmethod
+    def extract_all_paths(obj, path=""):
+        paths = []
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                new_path = f"{path}.{k}" if path else f".{k}"
+                paths.append(new_path)
+                paths.extend(DataOperationsComponent.extract_all_paths(v, new_path))
+        elif isinstance(obj, list) and obj:
+            new_path = f"{path}[0]"
+            paths.append(new_path)
+            paths.extend(DataOperationsComponent.extract_all_paths(obj[0], new_path))
+        return paths
+
+    @staticmethod
+    def remove_keys_recursive(obj, keys_to_remove):
+        if isinstance(obj, dict):
+            return {
+                k: DataOperationsComponent.remove_keys_recursive(v, keys_to_remove)
+                for k, v in obj.items()
+                if k not in keys_to_remove
+            }
+        if isinstance(obj, list):
+            return [DataOperationsComponent.remove_keys_recursive(item, keys_to_remove) for item in obj]
+        return obj
+
+    @staticmethod
+    def rename_keys_recursive(obj, rename_map):
+        if isinstance(obj, dict):
+            return {
+                rename_map.get(k, k): DataOperationsComponent.rename_keys_recursive(v, rename_map)
+                for k, v in obj.items()
+            }
+        if isinstance(obj, list):
+            return [DataOperationsComponent.rename_keys_recursive(item, rename_map) for item in obj]
+        return obj
+
     inputs = [
         DataInput(name="data", display_name="Data", info="Data object to filter.", required=True, is_list=True),
         SortableListInput(
@@ -86,6 +133,8 @@ class DataOperationsComponent(Component):
                 {"name": "Append or Update", "icon": "circle-plus"},
                 {"name": "Remove Keys", "icon": "eraser"},
                 {"name": "Rename Keys", "icon": "pencil-line"},
+                {"name": "Path Selection", "icon": "mouse-pointer"},
+                {"name": "JQ Expression", "icon": "terminal"},
             ],
             real_time_refresh=True,
             limit=1,
@@ -94,7 +143,7 @@ class DataOperationsComponent(Component):
         MessageTextInput(
             name="select_keys_input",
             display_name="Select Keys",
-            info="List of keys to select from the data.",
+            info="List of keys to select from the data. Only top-level keys can be selected.",
             show=False,
             is_list=True,
         ),
@@ -102,7 +151,10 @@ class DataOperationsComponent(Component):
         MessageTextInput(
             name="filter_key",
             display_name="Filter Key",
-            info="Key to filter by.",
+            info=(
+                "Name of the key containing the list to filter. "
+                "It must be a top-level key in the JSON and its value must be a list."
+            ),
             is_list=True,
             show=False,
         ),
@@ -126,7 +178,7 @@ class DataOperationsComponent(Component):
         DictInput(
             name="append_update_data",
             display_name="Append or Update",
-            info="Data to Append or Updatethe existing data with.",
+            info="Data to append or update the existing data with. Only top-level keys are checked.",
             show=False,
             value={"key": "value"},
             is_list=True,
@@ -148,6 +200,26 @@ class DataOperationsComponent(Component):
             is_list=True,
             value={"old_key": "new_key"},
         ),
+        MultilineInput(
+            name="mapped_json_display",
+            display_name="JSON to Map",
+            info="Paste or preview your JSON here to explore its structure and select a path for extraction.",
+            required=False,
+            refresh_button=True,
+            real_time_refresh=True,
+            placeholder="Add a JSON example.",
+            show=False,
+        ),
+        DropdownInput(
+            name="selected_key", display_name="Select Path", options=[], required=False, dynamic=True, show=False
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="JQ Expression",
+            info="JSON Query to filter the data. Used by Parse JSON operation.",
+            placeholder="e.g., .properties.id",
+            show=False,
+        ),
     ]
     outputs = [
         Output(display_name="Data", name="data_output", method="as_data"),
@@ -156,10 +228,39 @@ class DataOperationsComponent(Component):
     # Helper methods for data operations
     def get_data_dict(self) -> dict:
         """Extract data dictionary from Data object."""
-        # TODO: rasie error if it s list of data objects
         data = self.data[0] if isinstance(self.data, list) and len(self.data) == 1 else self.data
         return data.model_dump()
 
+    def json_query(self) -> Data:
+        import json
+
+        import jq
+
+        if not self.query or not self.query.strip():
+            msg = "JSON Query is required and cannot be blank."
+            raise ValueError(msg)
+        raw_data = self.get_data_dict()
+        try:
+            input_str = json.dumps(raw_data)
+            repaired = repair_json(input_str)
+            data_json = json.loads(repaired)
+            jq_input = data_json["data"] if isinstance(data_json, dict) and "data" in data_json else data_json
+            results = jq.compile(self.query).input(jq_input).all()
+            if not results:
+                msg = "No result from JSON query."
+                raise ValueError(msg)
+            result = results[0] if len(results) == 1 else results
+            if result is None or result == "None":
+                msg = "JSON query returned null/None. Check if the path exists in your data."
+                raise ValueError(msg)
+            if isinstance(result, dict):
+                return Data(data=result)
+            return Data(data={"result": result})
+        except (ValueError, TypeError, KeyError, json.JSONDecodeError) as e:
+            logger.error(f"JSON Query failed: {e}")
+            msg = f"JSON Query error: {e}"
+            raise ValueError(msg) from e
+
     def get_normalized_data(self) -> dict:
         """Get normalized data dictionary, handling the 'data' key if present."""
         data_dict = self.get_data_dict()
@@ -204,34 +305,22 @@ class DataOperationsComponent(Component):
         return Data(data=filtered)
 
     def remove_keys(self) -> Data:
-        """Remove specified keys from the data dictionary."""
+        """Remove specified keys from the data dictionary, recursively."""
         self.validate_single_data("Remove Keys")
         data_dict = self.get_normalized_data()
         remove_keys_input: list[str] = self.remove_keys_input
 
-        for key in remove_keys_input:
-            if key in data_dict:
-                data_dict.pop(key)
-            else:
-                logger.warning(f"Key '{key}' not found in data. Skipping removal.")
-
-        return Data(**data_dict)
+        filtered = DataOperationsComponent.remove_keys_recursive(data_dict, set(remove_keys_input))
+        return Data(data=filtered)
 
     def rename_keys(self) -> Data:
-        """Rename keys in the data dictionary."""
+        """Rename keys in the data dictionary, recursively."""
         self.validate_single_data("Rename Keys")
         data_dict = self.get_normalized_data()
         rename_keys_input: dict[str, str] = self.rename_keys_input
 
-        for old_key, new_key in rename_keys_input.items():
-            if old_key in data_dict:
-                data_dict[new_key] = data_dict[old_key]
-                data_dict.pop(old_key)
-            else:
-                msg = f"Key '{old_key}' not found in data. Skipping rename."
-                raise ValueError(msg)
-
-        return Data(**data_dict)
+        renamed = DataOperationsComponent.rename_keys_recursive(data_dict, rename_keys_input)
+        return Data(data=renamed)
 
     def recursive_eval(self, data: Any) -> Any:
         """Recursively evaluate string values in a dictionary or list.
@@ -299,13 +388,6 @@ class DataOperationsComponent(Component):
 
         return Data(**combined_data)
 
-    def compare_values(self, item_value: Any, filter_value: str, operator: str) -> bool:
-        """Compare values based on the specified operator."""
-        comparison_func = OPERATORS.get(operator)
-        if comparison_func:
-            return comparison_func(item_value, filter_value)
-        return False
-
     def filter_data(self, input_data: list[dict[str, Any]], filter_key: str, filter_value: str, operator: str) -> list:
         """Filter list data based on key, value, and operator."""
         # Validate inputs
@@ -328,6 +410,12 @@ class DataOperationsComponent(Component):
 
         return filtered_data
 
+    def compare_values(self, item_value: Any, filter_value: str, operator: str) -> bool:
+        comparison_func = OPERATORS.get(operator)
+        if comparison_func:
+            return comparison_func(item_value, filter_value)
+        return False
+
     def multi_filter_data(self) -> Data:
         """Apply multiple filters to the data."""
         self.validate_single_data("Filter Values")
@@ -366,57 +454,59 @@ class DataOperationsComponent(Component):
 
     # Configuration and execution methods
     def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        """Update build configuration based on selected action."""
-        if field_name != "operations":
-            return build_config
-
-        build_config["operations"]["value"] = field_value
-        selected_actions = [action["name"] for action in field_value]
-
-        # Handle single action case
-        if len(selected_actions) == 1 and selected_actions[0] in ACTION_CONFIG:
-            action = selected_actions[0]
-            config = ACTION_CONFIG[action]
-
-            build_config["data"]["is_list"] = config["is_list"]
-            logger.info(config["log_msg"])
-
-            return set_current_fields(
-                build_config=build_config,
-                action_fields=self.actions_data,
-                selected_action=action,
-                default_fields=self.default_keys,
-                func=set_field_display,
-            )
-
-        # Handle no operations case
-        if not selected_actions:
-            logger.info("setting default fields")
-            return set_current_fields(
-                build_config=build_config,
-                action_fields=self.actions_data,
-                selected_action=None,
-                default_fields=self.default_keys,
-                func=set_field_display,
-            )
+        if field_name == "operations":
+            build_config["operations"]["value"] = field_value
+            selected_actions = [action["name"] for action in field_value]
+            if len(selected_actions) == 1 and selected_actions[0] in ACTION_CONFIG:
+                action = selected_actions[0]
+                config = ACTION_CONFIG[action]
+                build_config["data"]["is_list"] = config["is_list"]
+                logger.info(config["log_msg"])
+                return set_current_fields(
+                    build_config=build_config,
+                    action_fields=self.actions_data,
+                    selected_action=action,
+                    default_fields=["operations", "data"],
+                    func=set_field_display,
+                )
+
+        if field_name == "mapped_json_display":
+            try:
+                parsed_json = json.loads(field_value)
+                keys = DataOperationsComponent.extract_all_paths(parsed_json)
+                build_config["selected_key"]["options"] = keys
+                build_config["selected_key"]["show"] = True
+            except (json.JSONDecodeError, TypeError, ValueError) as e:
+                logger.error(f"Error parsing mapped JSON: {e}")
+                build_config["selected_key"]["show"] = False
 
         return build_config
 
+    def json_path(self) -> Data:
+        try:
+            if not self.data or not self.selected_key:
+                msg = "Missing input data or selected key."
+                raise ValueError(msg)
+            input_payload = self.data[0].data if isinstance(self.data, list) else self.data.data
+            compiled = jq.compile(self.selected_key)
+            result = compiled.input(input_payload).first()
+            if isinstance(result, dict):
+                return Data(data=result)
+            return Data(data={"result": result})
+        except (ValueError, TypeError, KeyError) as e:
+            self.status = f"Error: {e!s}"
+            self.log(self.status)
+            return Data(data={"error": str(e)})
+
     def as_data(self) -> Data:
-        """Execute the selected action on the data."""
         if not hasattr(self, "operations") or not self.operations:
             return Data(data={})
 
         selected_actions = [action["name"] for action in self.operations]
         logger.info(f"selected_actions: {selected_actions}")
-
-        # Only handle single action case for now
         if len(selected_actions) != 1:
             return Data(data={})
 
-        action = selected_actions[0]
-
-        # Explicitly type the action_map
         action_map: dict[str, Callable[[], Data]] = {
             "Select Keys": self.select_keys,
             "Literal Eval": self.evaluate_data,
@@ -425,14 +515,14 @@ class DataOperationsComponent(Component):
             "Append or Update": self.append_update,
             "Remove Keys": self.remove_keys,
             "Rename Keys": self.rename_keys,
+            "Path Selection": self.json_path,
+            "JQ Expression": self.json_query,
         }
-
-        handler: Callable[[], Data] | None = action_map.get(action)
+        handler: Callable[[], Data] | None = action_map.get(selected_actions[0])
         if handler:
             try:
                 return handler()
             except Exception as e:
-                logger.error(f"Error executing {action}: {e!s}")
+                logger.error(f"Error executing {selected_actions[0]}: {e!s}")
                 raise
-
         return Data(data={})

{lfx_nightly-0.1.12.dev0.dist-info → lfx_nightly-0.1.12.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev0
+Version: 0.1.12.dev2
 Summary: Langflow Executor - A lightweight CLI tool for executing and serving Langflow AI flows
 Author-email: Gabriel Luiz Freitas Almeida <gabriel@langflow.org>
 Requires-Python: <3.14,>=3.10

{lfx_nightly-0.1.12.dev0.dist-info → lfx_nightly-0.1.12.dev2.dist-info}/RECORD

@@ -29,7 +29,7 @@ lfx/base/curl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/curl/parse.py,sha256=Yw6mMbGg7e-ffrBItEUJeTiljneCXlNyt5afzEP9eUI,6094
 lfx/base/data/__init__.py,sha256=lQsYYMyAg_jA9ZF7oc-LNZsRE2uMGT6g16WzsUByHqs,81
 lfx/base/data/base_file.py,sha256=XFj3u9OGHcRbWfzslzvvxn-qpaCeX0uUQ0fStUCo65I,25495
-lfx/base/data/docling_utils.py,sha256=2kwI_eOPg-Wr2mfuGkOXFsW-53VqV8_F-XUTWruYMXg,9744
+lfx/base/data/docling_utils.py,sha256=i0KpNNLgPJ0D226Tm5j_oaCv09w9IspBU2OwTDCfnBc,11625
 lfx/base/data/utils.py,sha256=eZJgkOvQ3MaURDfgkH2MiZZOBF5_D0nSlmDY6LgLRik,5960
 lfx/base/document_transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/document_transformers/model.py,sha256=etVEmyakiEgflB-fayClPnFRhaEdXfdUu4cqpgtk8ek,1317
@@ -242,7 +242,7 @@ lfx/components/deepseek/__init__.py,sha256=gmyOcLeNEcnwSeowow0N0UhBDlSuZ_8x-DMUj
 lfx/components/deepseek/deepseek.py,sha256=yNrHoljXOMScKng-oSB-ceWhVZeuh11lmrAY7WiB2H0,4702
 lfx/components/docling/__init__.py,sha256=O4utz9GHFpTVe_Wy0PR80yA1irJQRnAFQWkoLCVj888,1424
 lfx/components/docling/chunk_docling_document.py,sha256=OX-jj4nX3UZgopViMAGAnFgtLql0sgs6cVmU8p9QbqA,7600
-lfx/components/docling/docling_inline.py,sha256=uq_YULsYVaz31A6HaHnE7rKacJXWAcEsC_LdWj_8arA,8278
+lfx/components/docling/docling_inline.py,sha256=-m8hTANtdUDUjsJtJTB1sl6MJMhXG8zMeBMwbn0w9Ig,7871
 lfx/components/docling/docling_remote.py,sha256=kwMS_-QMiM_JmPqvtHf4gDS73d2hZrIbtAPsN8bZxGE,6769
 lfx/components/docling/export_docling_document.py,sha256=TeFt3TesCxSqW57nv-30gf2dX8qMDUHLRhwU-1ciq08,4681
 lfx/components/documentloaders/__init__.py,sha256=LNl2hG2InevQCUREFKhF9ylaTf_kwPsdjiDbx2ElX3M,69
@@ -352,6 +352,7 @@ lfx/components/logic/conditional_router.py,sha256=xhNfHRsL_-81Jp51u7z59fjQuvUHlt
 lfx/components/logic/data_conditional_router.py,sha256=34QXJcZeL0vDDEhnyen1s-71yhO5FVhBTl2d5Am-OVI,5008
 lfx/components/logic/flow_tool.py,sha256=yxfUaTibZUAv6PZT-5zQX-KLS35iRjNPkLKKsVtyvh8,3966
 lfx/components/logic/listen.py,sha256=k_wRN3yW5xtG1CjTdGYhL5LxdgCZ0Bi9cbWP54FkyuY,935
+lfx/components/logic/llm_conditional_router.py,sha256=x-qCphrRd16yh_n2IQxqoCWu4AMMlI1QNLKBA0r7Rz8,16613
 lfx/components/logic/loop.py,sha256=F9vGbfAH-zDQgnJpVy9yk4fdrSIXz1gomnAOYW71Gto,4682
 lfx/components/logic/notify.py,sha256=A9aLooUwudRUsf2BRdE7CmGibCCRuQeCadneart9BEg,3086
 lfx/components/logic/pass_message.py,sha256=cdgzDjz6qSe2ekuCBzScWK8MI9spc81854iB-oQ3YGs,1039
@@ -406,7 +407,7 @@ lfx/components/processing/batch_run.py,sha256=KZtEaQMuSEUsQ5qwiU-dJPMAqNE5LA83Ho
 lfx/components/processing/combine_text.py,sha256=Zwh0F0v8vaTzmNK0T2D1c5LaixUKVINRZE8ulPjumKg,1242
 lfx/components/processing/converter.py,sha256=leNULEhmnkmB5dGfOmvlqGfY50870cebjTBfFFHAnX4,5140
 lfx/components/processing/create_data.py,sha256=PdoGU7hmDnLAtBxTTZQH72_B3mOdl8GDGcGgzrzsEkg,4422
-lfx/components/processing/data_operations.py,sha256=pojOpMEoc6WQsTZwVVev5YCGlCkibAEY9gcWwlcVrz8,16977
+lfx/components/processing/data_operations.py,sha256=9dloD4ZEvwlpQwpV2Tig6sGwWTOxWXb9gMX6RO_hiL0,21515
 lfx/components/processing/data_to_dataframe.py,sha256=5RT98DzwOHEzX0VHr1376sDiSw0GVpdLmF4zYT4XuVU,2323
 lfx/components/processing/dataframe_operations.py,sha256=tNaxm27vTkH_uVqqQ5k-c0HwVuvGAgNRzT0LCCbqmnI,11552
 lfx/components/processing/extract_key.py,sha256=wyX6uUzk9mlG3n_-CTIbNYEB9h9DDa4i_6ADRvUVOBU,1964
@@ -693,7 +694,7 @@ lfx/utils/schemas.py,sha256=NbOtVQBrn4d0BAu-0H_eCTZI2CXkKZlRY37XCSmuJwc,3865
 lfx/utils/util.py,sha256=xGR32XDRr_TtruhjnXfI7lEWmk-vgywHAy3kz5SBowc,15725
 lfx/utils/util_strings.py,sha256=nU_IcdphNaj6bAPbjeL-c1cInQPfTBit8mp5Y57lwQk,1686
 lfx/utils/version.py,sha256=cHpbO0OJD2JQAvVaTH_6ibYeFbHJV0QDHs_YXXZ-bT8,671
-lfx_nightly-0.1.12.dev0.dist-info/METADATA,sha256=2-HWdV_bpI8ChwlifgmnuZ7U8rEfbmdeaszShAytmIw,8000
-lfx_nightly-0.1.12.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.12.dev0.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.12.dev0.dist-info/RECORD,,
+lfx_nightly-0.1.12.dev2.dist-info/METADATA,sha256=E_Wuq_RZk_EafljGZMzaQkPtA3NpYNDjsYmE0iXp6PE,8000
+lfx_nightly-0.1.12.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.12.dev2.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.12.dev2.dist-info/RECORD,,