lfx-nightly 0.1.12.dev34__py3-none-any.whl → 0.1.12.dev35__py3-none-any.whl

lfx/base/tools/flow_tool.py

@@ -6,7 +6,7 @@ from langchain_core.tools import BaseTool, ToolException
 from typing_extensions import override
 
 from lfx.base.flow_processing.utils import build_data_from_result_data, format_flow_output_data
-from lfx.helpers.flow import build_schema_from_inputs, get_arg_names, get_flow_inputs, run_flow
+from lfx.helpers import build_schema_from_inputs, get_arg_names, get_flow_inputs, run_flow
 from lfx.log.logger import logger
 from lfx.utils.async_helpers import run_until_complete
 

lfx/base/tools/run_flow.py

@@ -5,7 +5,7 @@ from lfx.custom.custom_component.component import Component, get_component_toolk
 from lfx.field_typing import Tool
 from lfx.graph.graph.base import Graph
 from lfx.graph.vertex.base import Vertex
-from lfx.helpers.flow import get_flow_inputs
+from lfx.helpers import get_flow_inputs
 from lfx.inputs.inputs import DropdownInput, InputTypes, MessageInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data

lfx/cli/commands.py

@@ -85,6 +85,11 @@ def serve_command(
         cat my_flow.json | lfx serve --stdin
         echo '{"nodes": [...]}' | lfx serve --stdin
     """
+    # Configure logging with the specified level and import logger
+    from lfx.log.logger import configure, logger
+
+    configure(log_level=log_level)
+
     verbose_print = create_verbose_printer(verbose=verbose)
 
     # Validate input sources - exactly one must be provided
@@ -134,11 +139,11 @@ def serve_command(
     temp_file_to_cleanup = None
 
     if flow_json is not None:
-        verbose_print("Processing inline JSON content...")
+        logger.info("Processing inline JSON content...")
         try:
             # Validate JSON syntax
             json_data = json.loads(flow_json)
-            verbose_print("✓ JSON content is valid")
+            logger.info("JSON content is valid")
 
             # Create a temporary file with the JSON content
             with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
@@ -146,7 +151,7 @@ def serve_command(
                 temp_file_to_cleanup = temp_file.name
 
             script_path = temp_file_to_cleanup
-            verbose_print(f"✓ Created temporary file: {script_path}")
+            logger.info(f"Created temporary file: {script_path}")
 
         except json.JSONDecodeError as e:
             typer.echo(f"Error: Invalid JSON content: {e}", err=True)
@@ -156,17 +161,17 @@ def serve_command(
             raise typer.Exit(1) from e
 
     elif stdin:
-        verbose_print("Reading JSON content from stdin...")
+        logger.info("Reading JSON content from stdin...")
         try:
             # Read all content from stdin
             stdin_content = sys.stdin.read().strip()
             if not stdin_content:
-                verbose_print("Error: No content received from stdin")
+                logger.error("No content received from stdin")
                 raise typer.Exit(1)
 
             # Validate JSON syntax
             json_data = json.loads(stdin_content)
-            verbose_print("✓ JSON content from stdin is valid")
+            logger.info("JSON content from stdin is valid")
 
             # Create a temporary file with the JSON content
             with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
@@ -174,7 +179,7 @@ def serve_command(
                 temp_file_to_cleanup = temp_file.name
 
             script_path = temp_file_to_cleanup
-            verbose_print(f"✓ Created temporary file from stdin: {script_path}")
+            logger.info(f"Created temporary file from stdin: {script_path}")
 
         except json.JSONDecodeError as e:
             verbose_print(f"Error: Invalid JSON content from stdin: {e}")
@@ -210,10 +215,10 @@ def serve_command(
             raise typer.Exit(1)
 
         # Prepare the graph
-        verbose_print("Preparing graph for serving...")
+        logger.info("Preparing graph for serving...")
         try:
             graph.prepare()
-            verbose_print("✓ Graph prepared successfully")
+            logger.info("Graph prepared successfully")
 
             # Validate global variables for environment compatibility
             if check_variables:
@@ -221,12 +226,12 @@ def serve_command(
 
                 validation_errors = validate_global_variables_for_env(graph)
                 if validation_errors:
-                    verbose_print("✗ Global variable validation failed:")
+                    logger.error("Global variable validation failed:")
                     for error in validation_errors:
-                        verbose_print(f"  - {error}")
+                        logger.error(f"  - {error}")
                     raise typer.Exit(1)
             else:
-                verbose_print("✓ Global variable validation skipped")
+                logger.info("Global variable validation skipped")
         except Exception as e:
             verbose_print(f"✗ Failed to prepare graph: {e}")
             raise typer.Exit(1) from e

lfx/cli/run.py

@@ -18,18 +18,29 @@ from lfx.cli.validation import validate_global_variables_for_env
 from lfx.log.logger import logger
 from lfx.schema.schema import InputValueRequest
 
+# Verbosity level constants
+VERBOSITY_DETAILED = 2
+VERBOSITY_FULL = 3
 
-def output_error(error_message: str, *, verbose: bool) -> None:
+
+def output_error(error_message: str, *, verbose: bool, exception: Exception | None = None) -> None:
     """Output error in JSON format to stdout when not verbose, or to stderr when verbose."""
     if verbose:
         typer.echo(f"{error_message}", file=sys.stderr)
+
+    error_response = {
+        "success": False,
+        "type": "error",
+    }
+
+    # Add clean exception data if available
+    if exception:
+        error_response["exception_type"] = type(exception).__name__
+        error_response["exception_message"] = str(exception)
     else:
-        error_response = {
-            "success": False,
-            "error": error_message,
-            "type": "error",
-        }
-        typer.echo(json.dumps(error_response))
+        error_response["exception_message"] = error_message
+
+    typer.echo(json.dumps(error_response))
 
 
 @partial(syncify, raise_sync_error=False)
@@ -67,9 +78,20 @@ async def run(
         help="Check global variables for environment compatibility",
     ),
     verbose: bool = typer.Option(
-        default=False,
-        show_default=True,
-        help="Show diagnostic output and execution details",
+        False,  # noqa: FBT003
+        "-v",
+        "--verbose",
+        help="Show basic progress information",
+    ),
+    verbose_detailed: bool = typer.Option(
+        False,  # noqa: FBT003
+        "-vv",
+        help="Show detailed progress and debug information",
+    ),
+    verbose_full: bool = typer.Option(
+        False,  # noqa: FBT003
+        "-vvv",
+        help="Show full debugging output including component logs",
     ),
     timing: bool = typer.Option(
         default=False,
@@ -88,6 +110,8 @@ async def run(
         input_value: Input value to pass to the graph (positional argument)
         input_value_option: Input value to pass to the graph (alternative option)
         verbose: Show diagnostic output and execution details
+        verbose_detailed: Show detailed progress and debug information (-vv)
+        verbose_full: Show full debugging output including component logs (-vvv)
         output_format: Format for output (json, text, message, or result)
         flow_json: Inline JSON flow content as a string
         stdin: Read JSON flow content from stdin
@@ -96,15 +120,22 @@ async def run(
     """
     # Start timing if requested
     import time
-    from datetime import datetime
-
-    def verbose_print(message: str, level: str = "INFO") -> None:
-        if verbose:
-            timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]  # Include milliseconds  # noqa: DTZ005
-            typer.echo(f"[{timestamp}] {level}: {message}", file=sys.stderr)
 
-    def debug_print(message: str) -> None:
-        verbose_print(message, level="DEBUG")
+    # Configure logger based on verbosity level
+    from lfx.log.logger import configure
+
+    if verbose_full:
+        configure(log_level="DEBUG", output_file=sys.stderr)  # Show everything including component debug logs
+        verbosity = 3
+    elif verbose_detailed:
+        configure(log_level="DEBUG", output_file=sys.stderr)  # Show debug and above
+        verbosity = 2
+    elif verbose:
+        configure(log_level="INFO", output_file=sys.stderr)  # Show info and above including our CLI info messages
+        verbosity = 1
+    else:
+        configure(log_level="CRITICAL", output_file=sys.stderr)  # Only critical errors
+        verbosity = 0
 
     start_time = time.time() if timing else None
 
@@ -127,15 +158,18 @@ async def run(
     temp_file_to_cleanup = None
 
     if flow_json is not None:
-        verbose_print("Processing inline JSON content...")
+        if verbosity > 0:
+            typer.echo("Processing inline JSON content...", file=sys.stderr)
         try:
             json_data = json.loads(flow_json)
-            verbose_print("JSON content is valid")
+            if verbosity > 0:
+                typer.echo("JSON content is valid", file=sys.stderr)
             with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
                 json.dump(json_data, temp_file, indent=2)
                 temp_file_to_cleanup = temp_file.name
             script_path = Path(temp_file_to_cleanup)
-            verbose_print(f"Created temporary file: {script_path}")
+            if verbosity > 0:
+                typer.echo(f"Created temporary file: {script_path}", file=sys.stderr)
         except json.JSONDecodeError as e:
             output_error(f"Invalid JSON content: {e}", verbose=verbose)
             raise typer.Exit(1) from e
@@ -143,19 +177,22 @@ async def run(
             output_error(f"Error processing JSON content: {e}", verbose=verbose)
             raise typer.Exit(1) from e
     elif stdin:
-        verbose_print("Reading JSON content from stdin...")
+        if verbosity > 0:
+            typer.echo("Reading JSON content from stdin...", file=sys.stderr)
         try:
             stdin_content = sys.stdin.read().strip()
             if not stdin_content:
                 output_error("No content received from stdin", verbose=verbose)
                 raise typer.Exit(1)
             json_data = json.loads(stdin_content)
-            verbose_print("JSON content from stdin is valid")
+            if verbosity > 0:
+                typer.echo("JSON content from stdin is valid", file=sys.stderr)
             with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
                 json.dump(json_data, temp_file, indent=2)
                 temp_file_to_cleanup = temp_file.name
             script_path = Path(temp_file_to_cleanup)
-            verbose_print(f"Created temporary file from stdin: {script_path}")
+            if verbosity > 0:
+                typer.echo(f"Created temporary file from stdin: {script_path}", file=sys.stderr)
         except json.JSONDecodeError as e:
             output_error(f"Invalid JSON content from stdin: {e}", verbose=verbose)
             raise typer.Exit(1) from e
@@ -175,7 +212,8 @@ async def run(
             error_msg = f"'{script_path}' must be a .py or .json file."
             raise ValueError(error_msg)
         file_type = "Python script" if file_extension == ".py" else "JSON flow"
-        verbose_print(f"Analyzing {file_type}: {script_path}")
+        if verbosity > 0:
+            typer.echo(f"Analyzing {file_type}: {script_path}", file=sys.stderr)
         if file_extension == ".py":
             graph_info = find_graph_variable(script_path)
             if not graph_info:
@@ -183,47 +221,44 @@ async def run(
                     "No 'graph' variable found in the script. Expected to find an assignment like: graph = Graph(...)"
                 )
                 raise ValueError(error_msg)
-            verbose_print(f"Found 'graph' variable at line {graph_info['line_number']}")
-            verbose_print(f"Type: {graph_info['type']}")
-            verbose_print(f"Source: {graph_info['source_line']}")
-            verbose_print("Loading and executing script...")
+            if verbosity > 0:
+                typer.echo(f"Found 'graph' variable at line {graph_info['line_number']}", file=sys.stderr)
+                typer.echo(f"Type: {graph_info['type']}", file=sys.stderr)
+                typer.echo(f"Source: {graph_info['source_line']}", file=sys.stderr)
+                typer.echo("Loading and executing script...", file=sys.stderr)
             graph = load_graph_from_script(script_path)
         elif file_extension == ".json":
-            verbose_print("Valid JSON flow file detected")
-            verbose_print("\nLoading and executing JSON flow...")
+            if verbosity > 0:
+                typer.echo("Valid JSON flow file detected", file=sys.stderr)
+                typer.echo("Loading and executing JSON flow", file=sys.stderr)
             from lfx.load import aload_flow_from_json
 
             graph = await aload_flow_from_json(script_path, disable_logs=not verbose)
     except Exception as e:
         error_type = type(e).__name__
-        verbose_print(f"Graph loading failed with {error_type}", level="ERROR")
-
-        if verbose:
-            # Enhanced error context for better debugging
-            debug_print(f"Exception type: {error_type}")
-            debug_print(f"Exception message: {e!s}")
+        logger.error(f"Graph loading failed with {error_type}")
 
+        if verbosity > 0:
             # Try to identify common error patterns
             if "ModuleNotFoundError" in str(e) or "No module named" in str(e):
-                verbose_print("This appears to be a missing dependency issue", level="WARN")
+                logger.info("This appears to be a missing dependency issue")
                 if "langchain" in str(e).lower():
-                    verbose_print(
+                    logger.info(
                         "Missing LangChain dependency detected. Try: pip install langchain-<provider>",
-                        level="WARN",
                     )
             elif "ImportError" in str(e):
-                verbose_print("This appears to be an import issue - check component dependencies", level="WARN")
+                logger.info("This appears to be an import issue - check component dependencies")
             elif "AttributeError" in str(e):
-                verbose_print("This appears to be a component configuration issue", level="WARN")
+                logger.info("This appears to be a component configuration issue")
 
             # Show full traceback in debug mode
-            logger.exception("Failed to load graph - full traceback:")
+            logger.exception("Failed to load graph.")
 
-        output_error(f"Failed to load graph: {e}", verbose=verbose)
+        output_error(f"Failed to load graph. {e}", verbose=verbose, exception=e)
         if temp_file_to_cleanup:
             try:
                 Path(temp_file_to_cleanup).unlink()
-                verbose_print(f"Cleaned up temporary file: {temp_file_to_cleanup}", level="SUCCESS")
+                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
             except OSError:
                 pass
         raise typer.Exit(1) from e
@@ -233,70 +268,70 @@ async def run(
     # Mark end of loading phase if timing
     load_end_time = time.time() if timing else None
 
-    verbose_print("Preparing graph for execution...")
+    if verbosity > 0:
+        typer.echo("Preparing graph for execution...", file=sys.stderr)
     try:
         # Add detailed preparation steps
-        if verbose:
-            debug_print(f"Graph contains {len(graph.vertices)} vertices")
-            debug_print(f"Graph contains {len(graph.edges)} edges")
+        if verbosity > 0:
+            logger.debug(f"Graph contains {len(graph.vertices)} vertices")
+            logger.debug(f"Graph contains {len(graph.edges)} edges")
 
             # Show component types being used
             component_types = set()
             for vertex in graph.vertices:
                 if hasattr(vertex, "display_name"):
                     component_types.add(vertex.display_name)
-            debug_print(f"Component types in graph: {', '.join(sorted(component_types))}")
+            logger.debug(f"Component types in graph: {', '.join(sorted(component_types))}")
 
         graph.prepare()
-        verbose_print("Graph preparation completed", level="SUCCESS")
+        logger.info("Graph preparation completed")
 
         # Validate global variables for environment compatibility
         if check_variables:
-            verbose_print("Validating global variables...")
+            logger.info("Validating global variables...")
             validation_errors = validate_global_variables_for_env(graph)
             if validation_errors:
                 error_details = "Global variable validation failed: " + "; ".join(validation_errors)
-                verbose_print(f"Variable validation failed: {len(validation_errors)} errors", level="ERROR")
+                logger.info(f"Variable validation failed: {len(validation_errors)} errors")
                 for error in validation_errors:
-                    debug_print(f"Validation error: {error}")
+                    logger.debug(f"Validation error: {error}")
                 output_error(error_details, verbose=verbose)
             if temp_file_to_cleanup:
                 try:
                     Path(temp_file_to_cleanup).unlink()
-                    verbose_print(f"Cleaned up temporary file: {temp_file_to_cleanup}", level="SUCCESS")
+                    logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
                 except OSError:
                     pass
             if validation_errors:
                 raise typer.Exit(1)
-            verbose_print("Global variable validation passed", level="SUCCESS")
+            logger.info("Global variable validation passed")
         else:
-            verbose_print("Global variable validation skipped", level="SUCCESS")
+            logger.info("Global variable validation skipped")
     except Exception as e:
         error_type = type(e).__name__
-        verbose_print(f"Graph preparation failed with {error_type}", level="ERROR")
+        logger.info(f"Graph preparation failed with {error_type}")
 
-        if verbose:
-            debug_print(f"Preparation error: {e!s}")
+        if verbosity > 0:
+            logger.debug(f"Preparation error: {e!s}")
             logger.exception("Failed to prepare graph - full traceback:")
 
-        output_error(f"Failed to prepare graph: {e}", verbose=verbose)
+        output_error(f"Failed to prepare graph: {e}", verbose=verbose, exception=e)
         if temp_file_to_cleanup:
             try:
                 Path(temp_file_to_cleanup).unlink()
-                verbose_print(f"Cleaned up temporary file: {temp_file_to_cleanup}")
+                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
             except OSError:
                 pass
         raise typer.Exit(1) from e
 
-    verbose_print("Executing graph...")
+    logger.info("Executing graph...")
     execution_start_time = time.time() if timing else None
-
     if verbose:
-        debug_print("Setting up execution environment")
+        logger.debug("Setting up execution environment")
         if inputs:
-            debug_print(f"Input provided: {inputs.input_value}")
+            logger.debug(f"Input provided: {inputs.input_value}")
         else:
-            debug_print("No input provided")
+            logger.debug("No input provided")
 
     captured_stdout = StringIO()
     captured_stderr = StringIO()
@@ -309,18 +344,20 @@ async def run(
 
     try:
         sys.stdout = captured_stdout
-        sys.stderr = captured_stderr
+        # Don't capture stderr at high verbosity levels to avoid duplication with direct logging
+        if verbosity < VERBOSITY_FULL:
+            sys.stderr = captured_stderr
         results = []
 
-        verbose_print("Starting graph execution...", level="DEBUG")
+        logger.info("Starting graph execution...", level="DEBUG")
         result_count = 0
 
         async for result in graph.async_start(inputs):
             result_count += 1
-            if verbose:
-                debug_print(f"Processing result #{result_count}")
+            if verbosity > 0:
+                logger.debug(f"Processing result #{result_count}")
                 if hasattr(result, "vertex") and hasattr(result.vertex, "display_name"):
-                    debug_print(f"Component: {result.vertex.display_name}")
+                    logger.debug(f"Component: {result.vertex.display_name}")
             if timing:
                 step_end_time = time.time()
                 step_duration = step_end_time - execution_step_start
@@ -342,46 +379,70 @@ async def run(
 
             results.append(result)
 
-        verbose_print(f"Graph execution completed. Processed {result_count} results", level="SUCCESS")
+        logger.info(f"Graph execution completed. Processed {result_count} results")
 
     except Exception as e:
-        sys.stdout = original_stdout
-        sys.stderr = original_stderr
-
         error_type = type(e).__name__
-        verbose_print(f"Graph execution failed with {error_type}", level="ERROR")
+        logger.info(f"Graph execution failed with {error_type}")
 
-        if verbose:
-            debug_print(f"Execution error: {e!s}")
-            debug_print(f"Failed after processing {result_count} results")
+        if verbosity >= VERBOSITY_DETAILED:  # Only show details at -vv and above
+            logger.debug(f"Failed after processing {result_count} results")
 
+        # Only show component output at maximum verbosity (-vvv)
+        if verbosity >= VERBOSITY_FULL:
             # Capture any output that was generated before the error
-            captured_content = captured_stdout.getvalue() + captured_stderr.getvalue()
+            # Only show captured stdout since stderr logging is already shown directly in verbose mode
+            captured_content = captured_stdout.getvalue()
             if captured_content.strip():
-                debug_print("Captured output before error:")
-                for line in captured_content.strip().split("\n"):
-                    debug_print(f"  | {line}")
+                # Check if captured content contains the same error that will be displayed at the end
+                error_text = str(e)
+                captured_lines = captured_content.strip().split("\n")
+
+                # Filter out lines that are duplicates of the final error message
+                unique_lines = [
+                    line
+                    for line in captured_lines
+                    if not any(
+                        error_part.strip() in line for error_part in error_text.split("\n") if error_part.strip()
+                    )
+                ]
+
+                if unique_lines:
+                    logger.info("Component output before error:", level="DEBUG")
+                    for line in unique_lines:
+                        # Log each line directly using the logger to avoid nested formatting
+                        if verbosity > 0:
+                            # Remove any existing timestamp prefix to avoid duplication
+                            clean_line = line
+                            if "] " in line and line.startswith("2025-"):
+                                # Extract just the log message after the timestamp and level
+                                parts = line.split("] ", 1)
+                                if len(parts) > 1:
+                                    clean_line = parts[1]
+                            logger.debug(clean_line)
 
             # Provide context about common execution errors
             if "list can't be used in 'await' expression" in str(e):
-                verbose_print("This appears to be an async/await mismatch in a component", level="WARN")
-                verbose_print("Check that async methods are properly awaited", level="WARN")
+                logger.info("This appears to be an async/await mismatch in a component")
+                logger.info("Check that async methods are properly awaited")
             elif "AttributeError" in error_type and "NoneType" in str(e):
-                verbose_print("This appears to be a null reference error", level="WARN")
-                verbose_print("A component may be receiving unexpected None values", level="WARN")
+                logger.info("This appears to be a null reference error")
+                logger.info("A component may be receiving unexpected None values")
             elif "ConnectionError" in str(e) or "TimeoutError" in str(e):
-                verbose_print("This appears to be a network connectivity issue", level="WARN")
-                verbose_print("Check API keys and network connectivity", level="WARN")
+                logger.info("This appears to be a network connectivity issue")
+                logger.info("Check API keys and network connectivity")
 
             logger.exception("Failed to execute graph - full traceback:")
 
-        output_error(f"Failed to execute graph: {e}", verbose=verbose)
         if temp_file_to_cleanup:
             try:
                 Path(temp_file_to_cleanup).unlink()
-                verbose_print(f"Cleaned up temporary file: {temp_file_to_cleanup}", level="SUCCESS")
+                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
             except OSError:
                 pass
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        output_error(f"Failed to execute graph: {e}", verbose=verbosity > 0, exception=e)
         raise typer.Exit(1) from e
     finally:
         sys.stdout = original_stdout
@@ -389,7 +450,7 @@ async def run(
         if temp_file_to_cleanup:
             try:
                 Path(temp_file_to_cleanup).unlink()
-                verbose_print(f"Cleaned up temporary file: {temp_file_to_cleanup}")
+                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
             except OSError:
                 pass
 
@@ -424,7 +485,7 @@ async def run(
         result_data["logs"] = captured_logs
         if timing_metadata:
             result_data["timing"] = timing_metadata
-        indent = 2 if verbose else None
+        indent = 2 if verbosity > 0 else None
         typer.echo(json.dumps(result_data, indent=indent))
     elif output_format in {"text", "message"}:
         result_data = extract_structured_result(results)
@@ -437,5 +498,5 @@ async def run(
         result_data["logs"] = captured_logs
         if timing_metadata:
             result_data["timing"] = timing_metadata
-        indent = 2 if verbose else None
+        indent = 2 if verbosity > 0 else None
         typer.echo(json.dumps(result_data, indent=indent))

lfx/components/deactivated/sub_flow.py

@@ -4,7 +4,7 @@ from lfx.base.flow_processing.utils import build_data_from_result_data
 from lfx.custom.custom_component.custom_component import CustomComponent
 from lfx.graph.graph.base import Graph
 from lfx.graph.vertex.base import Vertex
-from lfx.helpers.flow import get_flow_inputs
+from lfx.helpers import get_flow_inputs
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict

lfx/components/logic/flow_tool.py

@@ -6,7 +6,7 @@ from lfx.base.langchain_utilities.model import LCToolComponent
 from lfx.base.tools.flow_tool import FlowTool
 from lfx.field_typing import Tool
 from lfx.graph.graph.base import Graph
-from lfx.helpers.flow import get_flow_inputs
+from lfx.helpers import get_flow_inputs
 from lfx.io import BoolInput, DropdownInput, Output, StrInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data

lfx/components/logic/run_flow.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 from lfx.base.tools.run_flow import RunFlowBaseComponent
-from lfx.helpers.flow import run_flow
+from lfx.helpers import run_flow
 from lfx.log.logger import logger
 from lfx.schema.dotdict import dotdict
 

lfx/components/logic/sub_flow.py

@@ -4,7 +4,7 @@ from lfx.base.flow_processing.utils import build_data_from_result_data
 from lfx.custom.custom_component.component import Component
 from lfx.graph.graph.base import Graph
 from lfx.graph.vertex.base import Vertex
-from lfx.helpers.flow import get_flow_inputs
+from lfx.helpers import get_flow_inputs
 from lfx.io import DropdownInput, Output
 from lfx.log.logger import logger
 from lfx.schema.data import Data

lfx/custom/custom_component/custom_component.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel
 
 from lfx.custom import validate
 from lfx.custom.custom_component.base_component import BaseComponent
-from lfx.helpers.flow import list_flows, load_flow, run_flow
+from lfx.helpers import list_flows, load_flow, run_flow
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.services.deps import get_storage_service, get_variable_service, session_scope

lfx/graph/vertex/param_handler.py

@@ -161,7 +161,7 @@ class ParameterHandler:
         elif field.get("required"):
             field_display_name = field.get("display_name")
             logger.warning(
-                "File path not found for {} in component {}. Setting to None.",
+                "File path not found for %s in component %s. Setting to None.",
                 field_display_name,
                 self.vertex.display_name,
             )
@@ -255,7 +255,7 @@ class ParameterHandler:
             else:
                 params[field_name] = ast.literal_eval(val) if val else None
         except Exception:  # noqa: BLE001
-            logger.debug("Error evaluating code for {}", field_name)
+            logger.debug("Error evaluating code for %s", field_name)
             params[field_name] = val
         return params
 

lfx/helpers/__init__.py

@@ -1 +1,129 @@
-"""Helpers module for lfx package."""
+"""Helpers module for the lfx package.
+
+This module automatically chooses between the full langflow implementation
+(when available) and the lfx implementation (when standalone).
+"""
+
+from lfx.utils.langflow_utils import has_langflow_memory
+
+# Import the appropriate implementation
+if has_langflow_memory():
+    try:
+        # Import full langflow implementation
+        # Base Model
+        from langflow.helpers.base_model import (
+            BaseModel,
+            SchemaField,
+            build_model_from_schema,
+            coalesce_bool,
+        )
+
+        # Custom
+        from langflow.helpers.custom import (
+            format_type,
+        )
+
+        # Data
+        from langflow.helpers.data import (
+            clean_string,
+            data_to_text,
+            data_to_text_list,
+            docs_to_data,
+            safe_convert,
+        )
+
+        # Flow
+        from langflow.helpers.flow import (
+            build_schema_from_inputs,
+            get_arg_names,
+            get_flow_inputs,
+            list_flows,
+            load_flow,
+            run_flow,
+        )
+    except ImportError:
+        # Fallback to lfx implementation if langflow import fails
+        # Base Model
+        from lfx.helpers.base_model import (
+            BaseModel,
+            SchemaField,
+            build_model_from_schema,
+            coalesce_bool,
+        )
+
+        # Custom
+        from lfx.helpers.custom import (
+            format_type,
+        )
+
+        # Data
+        from lfx.helpers.data import (
+            clean_string,
+            data_to_text,
+            data_to_text_list,
+            docs_to_data,
+            safe_convert,
+        )
+
+        # Flow
+        from lfx.helpers.flow import (
+            build_schema_from_inputs,
+            get_arg_names,
+            get_flow_inputs,
+            list_flows,
+            load_flow,
+            run_flow,
+        )
+else:
+    # Use lfx implementation
+    # Base Model
+    from lfx.helpers.base_model import (
+        BaseModel,
+        SchemaField,
+        build_model_from_schema,
+        coalesce_bool,
+    )
+
+    # Custom
+    from lfx.helpers.custom import (
+        format_type,
+    )
+
+    # Data
+    from lfx.helpers.data import (
+        clean_string,
+        data_to_text,
+        data_to_text_list,
+        docs_to_data,
+        safe_convert,
+    )
+
+    # Flow
+    from lfx.helpers.flow import (
+        build_schema_from_inputs,
+        get_arg_names,
+        get_flow_inputs,
+        list_flows,
+        load_flow,
+        run_flow,
+    )
+
+# Export the available functions
+__all__ = [
+    "BaseModel",
+    "SchemaField",
+    "build_model_from_schema",
+    "build_schema_from_inputs",
+    "clean_string",
+    "coalesce_bool",
+    "data_to_text",
+    "data_to_text_list",
+    "docs_to_data",
+    "format_type",
+    "get_arg_names",
+    "get_flow_inputs",
+    "list_flows",
+    "load_flow",
+    "run_flow",
+    "safe_convert",
+]

lfx/helpers/flow.py

@@ -189,6 +189,3 @@ async def run_flow(
         types=types,
         fallback_to_env_vars=fallback_to_env_vars,
     )
-
-
-__all__ = ["build_schema_from_inputs", "get_arg_names", "get_flow_inputs", "list_flows", "load_flow", "run_flow"]

lfx/inputs/input_mixin.py

@@ -12,6 +12,7 @@ from pydantic import (
 
 from lfx.field_typing.range_spec import RangeSpec
 from lfx.inputs.validators import CoalesceBool
+from lfx.schema.cross_module import CrossModuleModel
 
 
 class FieldTypes(str, Enum):
@@ -42,7 +43,7 @@ SerializableFieldTypes = Annotated[FieldTypes, PlainSerializer(lambda v: v.value
 
 
 # Base mixin for common input field attributes and methods
-class BaseInputMixin(BaseModel, validate_assignment=True):  # type: ignore[call-arg]
+class BaseInputMixin(CrossModuleModel, validate_assignment=True):  # type: ignore[call-arg]
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
         extra="forbid",

lfx/inputs/inputs.py

@@ -190,24 +190,15 @@ class MessageInput(StrInput, InputTraceMixin):
         # If v is a instance of Message, then its fine
         if isinstance(v, dict):
             return Message(**v)
+        # Duck-typed Message check - works across module boundaries
         if isinstance(v, Message):
+            # If it's from a different module (e.g., langflow.schema.Message),
+            # convert it to ensure we have the right type
+            if type(v).__module__ != Message.__module__:
+                return Message(**v.model_dump())
             return v
-        # Check for Message-like objects by examining their fields
-        # This handles both langflow and lfx Message instances
-        if hasattr(v, "text") and hasattr(v, "model_dump") and callable(v.model_dump):
-            # Check if it has other Message-specific attributes
-            message_fields = {"text", "data", "sender", "session_id", "properties"}
-            obj_attrs = set(dir(v))
-            min_message_fields = 3
-            if len(message_fields.intersection(obj_attrs)) >= min_message_fields:
-                try:
-                    return Message(**v.model_dump())
-                except (TypeError, ValueError):
-                    # Fallback to text only if model_dump fails
-                    return Message(text=v.text)
         if isinstance(v, str | AsyncIterator | Iterator):
             return Message(text=v)
-        # For simplified implementation, we'll skip MessageBase handling
         msg = f"Invalid value type {type(v)}"
         raise ValueError(msg)
 

lfx/log/logger.py

@@ -209,6 +209,7 @@ def configure(
     log_format: str | None = None,
     log_rotation: str | None = None,
     cache: bool | None = None,
+    output_file=None,
 ) -> None:
     """Configure the logger."""
     # Early-exit only if structlog is configured AND current min level matches the requested one.
@@ -297,11 +298,14 @@ def configure(
     wrapper_class.min_level = numeric_level
 
     # Configure structlog
+    # Default to stdout for backward compatibility, unless output_file is specified
+    log_output_file = output_file if output_file is not None else sys.stdout
+
     structlog.configure(
         processors=processors,
         wrapper_class=wrapper_class,
         context_class=dict,
-        logger_factory=structlog.PrintLoggerFactory(file=sys.stdout)
+        logger_factory=structlog.PrintLoggerFactory(file=log_output_file)
         if not log_file
         else structlog.stdlib.LoggerFactory(),
         cache_logger_on_first_use=cache if cache is not None else True,

lfx/memory/__init__.py

@@ -1,35 +1,15 @@
 """Memory management for lfx with dynamic loading.
 
-This module automatically chooses between full langflow implementations
-(when available) and lfx stub implementations (when standalone).
+This module automatically chooses between the full langflow implementation
+(when available) and the lfx implementation (when standalone).
 """
 
-import importlib.util
+from lfx.utils.langflow_utils import has_langflow_memory
 
-from lfx.log.logger import logger
-
-
-def _has_langflow_memory():
-    """Check if langflow.memory with database support is available."""
-    try:
-        # Check if langflow.memory and MessageTable are available
-        return importlib.util.find_spec("langflow") is not None
-    except (ImportError, ModuleNotFoundError):
-        pass
-    except Exception as e:  # noqa: BLE001
-        logger.error(f"Error checking for langflow.memory: {e}")
-    return False
-
-
-#### TODO: This _LANGFLOW_AVAILABLE implementation should be changed later ####
-# Consider refactoring to lazy loading or a more robust service discovery mechanism
-# that can handle runtime availability changes.
-_LANGFLOW_AVAILABLE = _has_langflow_memory()
-
-# Import the appropriate implementations
-if _LANGFLOW_AVAILABLE:
+# Import the appropriate implementation
+if has_langflow_memory():
     try:
-        # Import from full langflow implementation
+        # Import full langflow implementation
         from langflow.memory import (
             aadd_messages,
             aadd_messagetables,
@@ -43,8 +23,8 @@ if _LANGFLOW_AVAILABLE:
             get_messages,
             store_message,
         )
-    except (ImportError, ModuleNotFoundError):
-        # Fall back to stubs if langflow import fails
+    except ImportError:
+        # Fallback to lfx implementation if langflow import fails
         from lfx.memory.stubs import (
             aadd_messages,
             aadd_messagetables,
@@ -59,7 +39,7 @@ if _LANGFLOW_AVAILABLE:
             store_message,
         )
 else:
-    # Use lfx stub implementations
+    # Use lfx implementation
     from lfx.memory.stubs import (
         aadd_messages,
         aadd_messagetables,
@@ -74,7 +54,7 @@ else:
         store_message,
     )
 
-# Export the available functions and classes
+# Export the available functions
 __all__ = [
     "aadd_messages",
     "aadd_messagetables",

lfx/schema/cross_module.py

@@ -0,0 +1,80 @@
+"""Cross-module BaseModel for handling re-exported classes.
+
+This module provides a metaclass and base model that enable isinstance checks
+to work across module boundaries for Pydantic models. This is particularly useful
+when the same class is re-exported from different modules (e.g., lfx.Message vs
+langflow.schema.Message) but Python's isinstance() checks fail due to different
+module paths.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class CrossModuleMeta(type(BaseModel)):  # type: ignore[misc]
+    """Metaclass that enables cross-module isinstance checks for Pydantic models.
+
+    This metaclass overrides __instancecheck__ to perform structural type checking
+    based on the model's fields rather than strict class identity. This allows
+    instances of the same model from different module paths to be recognized as
+    compatible.
+    """
+
+    def __instancecheck__(cls, instance: Any) -> bool:
+        """Check if instance is compatible with this class across module boundaries.
+
+        First performs a standard isinstance check. If that fails, falls back to
+        checking if the instance has all required Pydantic model attributes and
+        a compatible set of model fields.
+
+        Args:
+            instance: The object to check.
+
+        Returns:
+            bool: True if instance is compatible with this class.
+        """
+        # First try standard isinstance check
+        if type.__instancecheck__(cls, instance):
+            return True
+
+        # If that fails, check for cross-module compatibility
+        # An object is cross-module compatible if it:
+        # 1. Has model_fields attribute (is a Pydantic model)
+        # 2. Has the same __class__.__name__
+        # 3. Has compatible model fields
+        if not hasattr(instance, "model_fields"):
+            return False
+
+        # Check if class names match
+        if instance.__class__.__name__ != cls.__name__:
+            return False
+
+        # Check if the instance has all required fields from cls
+        cls_fields = set(cls.model_fields.keys()) if hasattr(cls, "model_fields") else set()
+        instance_fields = set(instance.model_fields.keys())
+
+        # The instance must have at least the same fields as the class
+        # (it can have more, but not fewer required fields)
+        return cls_fields.issubset(instance_fields)
+
+
+class CrossModuleModel(BaseModel, metaclass=CrossModuleMeta):
+    """Base Pydantic model with cross-module isinstance support.
+
+    This class should be used as the base for models that may be re-exported
+    from different modules. It enables isinstance() checks to work across
+    module boundaries by using structural type checking.
+
+    Example:
+        >>> class Message(CrossModuleModel):
+        ...     text: str
+        ...
+        >>> # Even if Message is imported from different paths:
+        >>> from lfx.schema.message import Message as LfxMessage
+        >>> from langflow.schema import Message as LangflowMessage
+        >>> msg = LfxMessage(text="hello")
+        >>> isinstance(msg, LangflowMessage)  # True (with cross-module support)
+    """

lfx/schema/data.py

@@ -14,6 +14,7 @@ from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
 from pydantic import BaseModel, ConfigDict, model_serializer, model_validator
 
 from lfx.log.logger import logger
+from lfx.schema.cross_module import CrossModuleModel
 from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
 from lfx.utils.image import create_image_content_dict
 
@@ -22,7 +23,7 @@ if TYPE_CHECKING:
     from lfx.schema.message import Message
 
 
-class Data(BaseModel):
+class Data(CrossModuleModel):
     """Represents a record with text and optional data.
 
     Attributes:

lfx/utils/langflow_utils.py

@@ -0,0 +1,52 @@
+"""Langflow environment utility functions."""
+
+import importlib.util
+
+from lfx.log.logger import logger
+
+
+class _LangflowModule:
+    # Static variable
+    # Tri-state:
+    # - None: Langflow check not performed yet
+    # - True: Langflow is available
+    # - False: Langflow is not available
+    _available = None
+
+    @classmethod
+    def is_available(cls):
+        return cls._available
+
+    @classmethod
+    def set_available(cls, value):
+        cls._available = value
+
+
+def has_langflow_memory():
+    """Check if langflow.memory (with database support) and MessageTable are available."""
+    # TODO: REVISIT: Optimize this implementation later
+    # - Consider refactoring to use lazy loading or a more robust service discovery mechanism
+    #   that can handle runtime availability changes.
+
+    # Use cached check from previous invocation (if applicable)
+
+    is_langflow_available = _LangflowModule.is_available()
+
+    if is_langflow_available is not None:
+        return is_langflow_available
+
+    # First check (lazy load and cache check)
+
+    module_spec = None
+
+    try:
+        module_spec = importlib.util.find_spec("langflow")
+    except ImportError:
+        pass
+    except (TypeError, ValueError) as e:
+        logger.error(f"Error encountered checking for langflow.memory: {e}")
+
+    is_langflow_available = module_spec is not None
+    _LangflowModule.set_available(is_langflow_available)
+
+    return is_langflow_available

{lfx_nightly-0.1.12.dev34.dist-info → lfx_nightly-0.1.12.dev35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev34
+Version: 0.1.12.dev35
 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.dev34.dist-info → lfx_nightly-0.1.12.dev35.dist-info}/RECORD

@@ -81,16 +81,16 @@ lfx/base/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/tools/base.py,sha256=CMYJzYMoJoAeN9XVDRIKLfhHZO_WMM0wFsRHQQ2ommc,940
 lfx/base/tools/component_tool.py,sha256=WXc2is91CzcXWzzs5oAPaa0Rb_MpOhuzZTDDmfyoCwY,13490
 lfx/base/tools/constants.py,sha256=AgulV7M3axHeTKQOmls-9Z1C7pTfh6Er1qahtFS2am4,1535
-lfx/base/tools/flow_tool.py,sha256=Zz0-yyzqszir8wgd1bNyX3OVnQhM6AVFI4HnWmpQuu4,4852
-lfx/base/tools/run_flow.py,sha256=iPBX1PfKpTf--dL7lIt0g90_AkqIrJ0vvFhJ1azsBzY,9209
+lfx/base/tools/flow_tool.py,sha256=_NbedxYUPApBPza4uoRDeLSggLcjVLd_Z1Z9_Z7TDi4,4847
+lfx/base/tools/run_flow.py,sha256=2UD7MZMTla-cIdr5nGr6lp8pj6_iZgZtwvXcnLhXqas,9204
 lfx/base/vectorstores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/vectorstores/model.py,sha256=pDAZ6D6XnMxGAV9hJjc3DYhjI9n77sc_FIs5lnpsDbU,6932
 lfx/base/vectorstores/utils.py,sha256=OhBNYs9Z9poe82rTNFPdrESNRGuP6RO6-eOpwqJLBG0,750
 lfx/base/vectorstores/vector_store_connection_decorator.py,sha256=2gh3DMhcMsCgVYFEFaVNMT3zsbd-fkFy5Bl_-jXDu8c,1998
 lfx/cli/__init__.py,sha256=Oy17zrnwBlwJn80sMGyRJXos2n2eQGvSsh9CS_-v2R4,113
-lfx/cli/commands.py,sha256=_dbemp5WDrL8WFEw8FkG9CrxTyIFtxNqyxFR_3zNJvA,11815
+lfx/cli/commands.py,sha256=IR4leAtfQUjsc9wI6q1LRx--u4sW-i5ixtKdMYju-hI,11912
 lfx/cli/common.py,sha256=SvszBhWoOttM27rButhBOpvE8lO5UGMYL0NaG_OW8bc,22060
-lfx/cli/run.py,sha256=59e1vwvI5Isr3Is0YSx65985CeGYiOJIVD643VUwXCg,18775
+lfx/cli/run.py,sha256=_7JX6YpoO3XLCfD2BtZl3FsghMyo18B9SriLyO0EaoQ,21411
 lfx/cli/script_loader.py,sha256=xWSpx57cBeX0UHmUgAk97aye9-hhD2Y6nKh68A-xaTA,8997
 lfx/cli/serve_app.py,sha256=3U0QsoCkf-1DxSpxfNOr8ap7Giaxm_MfuLrii5GpIHM,22485
 lfx/cli/validation.py,sha256=xZfL-rKt_Y-Lek19GMZffyxhPIyYMQHBIpR0Hwa_Ji8,2615
@@ -253,7 +253,7 @@ lfx/components/deactivated/selective_passthrough.py,sha256=YQN7iyEvm-T_YIAYD1Bmz
 lfx/components/deactivated/should_run_next.py,sha256=xcSscsWs7Tte-nbZEpOxLrnu9CaUy98TBY70VPY0_WE,1613
 lfx/components/deactivated/split_text.py,sha256=i_DFal5-j10k_56A7pA7F86oQ2lTMFt2W6aKsmjD_Ks,2005
 lfx/components/deactivated/store_message.py,sha256=k_F6FiyVU-HWHulbKPgjrdh_Dg9g_H3E_H_RvrGSmsA,701
-lfx/components/deactivated/sub_flow.py,sha256=RLIJz2aNotCZXxDLzd8HLdwaRRLLNomMT7eUBmWc8_s,4795
+lfx/components/deactivated/sub_flow.py,sha256=xag1QeRaL0Ph3eqzWbgJtmK8q22kVyMdRyIq--vyWFw,4790
 lfx/components/deactivated/vectara_self_query.py,sha256=nlRFL-FIdecgpaR70ohC8TslIN44oNVUpOx1nScGq9k,2952
 lfx/components/deactivated/vector_store.py,sha256=7L1Z8Nl0RZjEGAj1O2tMhb6I6jUNNc5MBOui4a2FkXE,728
 lfx/components/deepseek/__init__.py,sha256=gmyOcLeNEcnwSeowow0N0UhBDlSuZ_8x-DMUjwkNRFM,935
@@ -371,14 +371,14 @@ lfx/components/lmstudio/lmstudiomodel.py,sha256=73bEJ2CgqsnoYWhtqNq2Fpe9yedHK9ud
 lfx/components/logic/__init__.py,sha256=nHxJDynHNaHDhdckwa8Y6UCyjlsoO0QcNaSPq51OuUM,1802
 lfx/components/logic/conditional_router.py,sha256=RQaoM9FF63vXw6rebKA_j4-Hl2YRNvHRtwEq5eT48yY,8692
 lfx/components/logic/data_conditional_router.py,sha256=b6G_QWajQqoFCQM-614QbrPoU2AVzkgMHA6AMUZybl0,5054
-lfx/components/logic/flow_tool.py,sha256=xOhqOX8teK19IPRBZ1WtvWHGWg7Ont6MT7LbMwhaDtA,3989
+lfx/components/logic/flow_tool.py,sha256=k0jXnRn0TIarE7cw61w80R-a_XmloRTIHioYGeZrBeU,3984
 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=BNPh7TOQ-svrhR2-uMQMMT0LBW0sT_zzIpbuWeEEPDY,1085
-lfx/components/logic/run_flow.py,sha256=jU62Gy_M6dLhQIqG6FXi5FpklvCE2pvCDIpNevKAKK8,2919
-lfx/components/logic/sub_flow.py,sha256=BCQG-0LDDp3TUcRwTGRXa4uu5-eGDVHZmGfnwTTVmps,4556
+lfx/components/logic/run_flow.py,sha256=DA08G-LYKmRr4srpLpfqma8iVUBdPEWYlOFgUrv6TDU,2914
+lfx/components/logic/sub_flow.py,sha256=i6b7xco678C9rUeShH7syIJlGXUL2XUk4-AWkOO3wd8,4551
 lfx/components/maritalk/__init__.py,sha256=7S6PYMe6VnaPE1BvQAnzJ2lGmSYsnTSj79biKsRYwrA,951
 lfx/components/maritalk/maritalk.py,sha256=JcXaMRgerniZCWKTEAYjORpvTp1b5mapyQO76F3A5oo,1813
 lfx/components/mem0/__init__.py,sha256=NwL5GN-YdRPXZU5Y5zd9hpTbBx6cPjVKG_8wwIGUiNs,85
@@ -565,7 +565,7 @@ lfx/custom/custom_component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 lfx/custom/custom_component/base_component.py,sha256=Pxi-qCocrGIwcG0x5fu-7ty1Py71bl_KG9Fku5SeO_M,4053
 lfx/custom/custom_component/component.py,sha256=6BIJxp6M8y1wCVUTGoQveYVDzeMDnuqcItcJpua_UUk,75795
 lfx/custom/custom_component/component_with_cache.py,sha256=por6CiPL3EHdLp_DvfI7qz1n4tc1KkqMOJNbsxoqVaI,313
-lfx/custom/custom_component/custom_component.py,sha256=u330P-UbRXKeO-ughl2rCyvEbgdq-igTNFYEoKQLJzI,22306
+lfx/custom/custom_component/custom_component.py,sha256=801FjGiQk7M7GD3CbU19AmCVS5KZjPVcKUy_wBXnm0o,22301
 lfx/custom/directory_reader/__init__.py,sha256=eFjlhKjpt2Kha_sJ2EqWofLRbpvfOTjvDSCpdpaTqWk,77
 lfx/custom/directory_reader/directory_reader.py,sha256=nuv9vxCjmOiVtT0pad0Xcz8mHfQ5ve0EvBWR6RokwdM,15269
 lfx/custom/directory_reader/utils.py,sha256=etts9VysmfP0kkbxn76shqLURPYZizF2YvEc4KeGPY4,6532
@@ -597,19 +597,19 @@ lfx/graph/vertex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 lfx/graph/vertex/base.py,sha256=drvm5o-y2NMyZ99uupHqjh4lUl8kIV4SeYol-q7FTdQ,33310
 lfx/graph/vertex/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/graph/vertex/exceptions.py,sha256=QTe-7TRCI0TXswRZh1kh0Z3KySjQsJgY5zTU6o0jboQ,193
-lfx/graph/vertex/param_handler.py,sha256=ugIsqxXd5YHYixbufW39VDgrfDICvI-im2U_oxiOWGM,12887
+lfx/graph/vertex/param_handler.py,sha256=o6RmGvdo8rzasIZaalkAvC3LJA7oS8ETqpmXnOtarI8,12887
 lfx/graph/vertex/schema.py,sha256=3h6c7TTdZI1mzfAebhD-6CCCRLu1mQ8UDmgJijx5zWg,552
 lfx/graph/vertex/utils.py,sha256=iJmY4PXta5dYWTX2SMEbpfMKrzwkJVQmi8qstSv8D7I,738
 lfx/graph/vertex/vertex_types.py,sha256=r4eMlTUTWR5CQf-W34BBzpHpQ9KdWcK3L-2byE22enU,21140
-lfx/helpers/__init__.py,sha256=LXLK77zpwi2yzfv3jPFVl6h1HVr0mybtnJ6nTgtPP74,38
+lfx/helpers/__init__.py,sha256=XUsPqOxQNoleWGC4EtVxqgaEQjR4cHsHOsyJ3Kjm88I,2912
 lfx/helpers/base_model.py,sha256=EiBdNJVE83BNKsg-IedyZYd78Mbl0m7BN2XTFeTlBhw,1956
 lfx/helpers/custom.py,sha256=9Z6rVfIrih27qsGkV1lzVpkK-ifpQuOaGSUog_w4asM,306
 lfx/helpers/data.py,sha256=1jGqlVrLEgr0M5J_wJf-vZ-IRTV13Jm5W6wuxYL2Hdg,6004
-lfx/helpers/flow.py,sha256=F_2sFOZaylgAvzp4zr-8JYFtI0S4FRZeONvAGmw3SwQ,5769
+lfx/helpers/flow.py,sha256=U5H-b7g6-12YutZF8DNIAmVPRqjI6P0TFntfCIzl46A,5653
 lfx/inputs/__init__.py,sha256=NeCBGqtJN7KGPpMmt6c4-840X9uafzYZGwXzkJ4bGqw,1213
 lfx/inputs/constants.py,sha256=vG60oUv1xy5vrnZtU65jBCzb6oaOuiRDq1ucl_9bz70,47
-lfx/inputs/input_mixin.py,sha256=r23bPxWb1Fo81kFU02a2KUGfPLNUhE6K9q1Zw4LH4Qw,10836
-lfx/inputs/inputs.py,sha256=y-SwcZhlEuVgLsOa2_x7wraUCaoZ3EV7_jrON9yuqPw,26220
+lfx/inputs/input_mixin.py,sha256=fRnx-0FjIG-Vf_BCaXFMysca5f9CvRVKYhsD6mtNLnY,10896
+lfx/inputs/inputs.py,sha256=jNZhr7Uud_YQ9gYBMrBeBbP-m2-n4pQQ1V-fp8eNFTc,25706
 lfx/inputs/validators.py,sha256=i_PyQHQUmNpeS-_jRJNNsP3WlTPMkCJk2iFmFt3_ijw,505
 lfx/interface/__init__.py,sha256=hlivcb8kMhU_V8VeXClNfz5fRyF-u5PZZMXkgu0U5a0,211
 lfx/interface/components.py,sha256=BotYhF246Ixm41AQb2aD5OJ7G8dIX_uE_55ZOrI4C70,20058
@@ -626,9 +626,9 @@ lfx/load/__init__.py,sha256=y35GBUhVTOsG3GzL5UVL-RNAsu0D7T8MVPrNXoDMx7U,224
 lfx/load/load.py,sha256=mpQG2RV2ZOysShEOguWKdnQI9TUub1Ds5j89ZbwiQhA,10451
 lfx/load/utils.py,sha256=qa8aoMLW-X8FO8xVz3YVHQwjTSJYbYr_AOQAAp3smlc,3705
 lfx/log/__init__.py,sha256=UATLSm1Fp9rVclAXP00LKQzzYKcaboVSuWNujlRR6P4,119
-lfx/log/logger.py,sha256=HyCROThKWoZ5OOVUuGWeyDRd_0x9haVrNRW2Ky0Bdek,14049
+lfx/log/logger.py,sha256=UaUlWEwws7SVa24_9ZuPwRgefoatzRV7nnZV7YQZjwU,14238
 lfx/logging/__init__.py,sha256=X5tXF5e1hc62adprRPLtKeaqm8-tpl6loXsxbh9IO-Q,367
-lfx/memory/__init__.py,sha256=XR7-FSeIxikpi6HSo1bYEXY4ua_1G6oHufD1OCRjynw,2531
+lfx/memory/__init__.py,sha256=s7nCNKlcwLfT6Z_cXbiYjvoXQXZ-H2GqK1qsAuKBV08,1815
 lfx/memory/stubs.py,sha256=kR6TRI2t6rPvA5Pja5XPC4yvKRBFBuJfdI0hJL8vfwU,9924
 lfx/processing/__init__.py,sha256=jERZg6it9mhOzrbTAt9YtakSNXPSjUXFh5MfKBN48wA,41
 lfx/processing/process.py,sha256=FSYjseEWEgfBxP4GDkfRVVSyrvXwyIb7U0pTVc1gV_w,9252
@@ -637,7 +637,8 @@ lfx/schema/__init__.py,sha256=PyFfbQryedA67VjrTbJMuGZaau1zHjVZ1YfZO4J8OW4,1656
 lfx/schema/artifact.py,sha256=ooWPuiolxsRI9jeTSSQecYTb8vyIaGwPF8C1udZ5kYo,2604
 lfx/schema/content_block.py,sha256=DBjj6O4UaV2bkzz7vcGP7-ZuLREl5O413LUfAz8bIbs,2042
 lfx/schema/content_types.py,sha256=Towg01dGR9PMC7JrVkzfIPYMMJttl16XC6BvQXH03bw,2390
-lfx/schema/data.py,sha256=dPHaQrwzF1XylecUDrhxs7v4TlzwNwvF-IB3Ufb0ZOQ,11666
+lfx/schema/cross_module.py,sha256=GiGYnzNHprKrxysf5hJxvvmy0GA0xxO_d3K1rUPGiA8,3148
+lfx/schema/data.py,sha256=g1E3Tjd-o42xwAfvWGj_exV5zB70WaOv-6seE9I0Rzk,11726
 lfx/schema/dataframe.py,sha256=Jo07krf3lI-dicAu5Y5Enf90NSEWkpD_di0rSj9krIM,7477
 lfx/schema/dotdict.py,sha256=d6R5jv8V_pxaQUX3QP41ZzTz2wZpnZ0OFsylFf3xL-Q,2756
 lfx/schema/encoders.py,sha256=7vlWHZnZuDv1UVuP9X7Xn8srP1HZqLygOmkps3EJyY0,332
@@ -713,13 +714,14 @@ lfx/utils/data_structure.py,sha256=xU3JNa_4jcGOVa_ctfMxiImEj6dKQQPE_zZsTAyy2T4,6
 lfx/utils/exceptions.py,sha256=RgIkI4uBssJsJUnuhluNGDSzdcuW5fnxPLhGfXYU9Uc,973
 lfx/utils/helpers.py,sha256=0LE0barnVp-8Y5cCoDRzhDzesvXqgiT7IXP6vtTSyGE,889
 lfx/utils/image.py,sha256=W9boQgz4WH3GOgLrYaRDz2CbX5Za8pzi044X3EKvYbI,2370
+lfx/utils/langflow_utils.py,sha256=JHCsYGAvpwXOhe8DrqFF08cYKGdjsz5_iA7glJDdEiY,1441
 lfx/utils/lazy_load.py,sha256=UDtXi8N7NT9r-FRGxsLUfDtGU_X8yqt-RQqgpc9TqAw,394
 lfx/utils/request_utils.py,sha256=A6vmwpr7f3ZUxHg6Sz2-BdUUsyAwg84-7N_DNoPC8_Q,518
 lfx/utils/schemas.py,sha256=NbOtVQBrn4d0BAu-0H_eCTZI2CXkKZlRY37XCSmuJwc,3865
 lfx/utils/util.py,sha256=Ww85wbr1-vjh2pXVtmTqoUVr6MXAW8S7eDx_Ys6HpE8,20696
 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.dev34.dist-info/METADATA,sha256=gNTSkSXCMVTO-NThZUB9QYis4SFNxIME5n0h_BBMJFY,8290
-lfx_nightly-0.1.12.dev34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.12.dev34.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.12.dev34.dist-info/RECORD,,
+lfx_nightly-0.1.12.dev35.dist-info/METADATA,sha256=15fUNw16xD_P0VF15znV4v47_8SRS1cEOAY2R05g-Fg,8290
+lfx_nightly-0.1.12.dev35.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.12.dev35.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.12.dev35.dist-info/RECORD,,