lfx-nightly 0.1.12.dev26__py3-none-any.whl → 0.1.12.dev28__py3-none-any.whl

lfx/graph/vertex/param_handler.py

@@ -182,6 +182,8 @@ class ParameterHandler:
             params = self._handle_code_field(field_name, val, params)
         elif field.get("type") in {"dict", "NestedDict"}:
             params = self._handle_dict_field(field_name, val, params)
+        elif field.get("type") == "table":
+            params = self._handle_table_field(field_name, val, params, load_from_db_fields)
         else:
             params = self._handle_other_direct_types(field_name, field, val, params)
 
@@ -190,6 +192,53 @@ class ParameterHandler:
 
         return params, load_from_db_fields
 
+    def _handle_table_field(
+        self,
+        field_name: str,
+        val: Any,
+        params: dict[str, Any],
+        load_from_db_fields: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Handle table field type with load_from_db column support."""
+        if load_from_db_fields is None:
+            load_from_db_fields = []
+        if val is None:
+            params[field_name] = []
+            return params
+
+        # Store the table data as-is for now
+        # The actual column processing will happen in the loading phase
+        if isinstance(val, list) and all(isinstance(item, dict) for item in val):
+            params[field_name] = val
+        else:
+            msg = f"Invalid value type {type(val)} for table field {field_name}"
+            raise ValueError(msg)
+
+        # Get table schema from the field to identify load_from_db columns
+        field_template = self.template_dict.get(field_name, {})
+        table_schema = field_template.get("table_schema", [])
+
+        # Track which columns need database loading
+        load_from_db_columns = []
+        for column_schema in table_schema:
+            if isinstance(column_schema, dict) and column_schema.get("load_from_db"):
+                load_from_db_columns.append(column_schema["name"])
+            elif hasattr(column_schema, "load_from_db") and column_schema.load_from_db:
+                load_from_db_columns.append(column_schema.name)
+
+        # Store metadata for later processing
+        if load_from_db_columns:
+            # Store table column metadata for the loading phase
+            table_load_metadata_key = f"{field_name}_load_from_db_columns"
+            params[table_load_metadata_key] = load_from_db_columns
+
+            # Add to load_from_db_fields so it gets processed
+            # We'll use a special naming convention to identify table fields
+            load_from_db_fields.append(f"table:{field_name}")
+            self.load_from_db_fields.append(f"table:{field_name}")
+
+        return params
+
     def handle_optional_field(self, field_name: str, field: dict, params: dict[str, Any]) -> None:
         """Handle optional fields."""
         if not field.get("required") and params.get(field_name) is None:

lfx/interface/initialize/loading.py

@@ -126,6 +126,88 @@ def load_from_env_vars(params, load_from_db_fields):
     return params
 
 
+async def update_table_params_with_load_from_db_fields(
+    custom_component: CustomComponent,
+    params: dict,
+    table_field_name: str,
+    *,
+    fallback_to_env_vars: bool = False,
+) -> dict:
+    """Update table parameters with load_from_db column values."""
+    # Get the table data and column metadata
+    table_data = params.get(table_field_name, [])
+    metadata_key = f"{table_field_name}_load_from_db_columns"
+    load_from_db_columns = params.pop(metadata_key, [])
+
+    if not table_data or not load_from_db_columns:
+        return params
+
+    async with session_scope() as session:
+        settings_service = get_settings_service()
+        is_noop_session = isinstance(session, NoopSession) or (
+            settings_service and settings_service.settings.use_noop_database
+        )
+
+        # Process each row in the table
+        updated_table_data = []
+        for row in table_data:
+            if not isinstance(row, dict):
+                updated_table_data.append(row)
+                continue
+
+            updated_row = row.copy()
+
+            # Process each column that needs database loading
+            for column_name in load_from_db_columns:
+                if column_name not in updated_row:
+                    continue
+
+                # The column value should be the name of the global variable to lookup
+                variable_name = updated_row[column_name]
+                if not variable_name:
+                    continue
+
+                try:
+                    if is_noop_session:
+                        # Fallback to environment variables
+                        key = os.getenv(variable_name)
+                        if key:
+                            logger.info(f"Using environment variable {variable_name} for table column {column_name}")
+                        else:
+                            logger.error(f"Environment variable {variable_name} is not set.")
+                    else:
+                        # Load from database
+                        key = await custom_component.get_variable(
+                            name=variable_name, field=f"{table_field_name}.{column_name}", session=session
+                        )
+
+                except ValueError as e:
+                    if "User id is not set" in str(e):
+                        raise
+                    logger.debug(str(e))
+                    key = None
+
+                # If we couldn't get from database and fallback is enabled, try environment
+                if fallback_to_env_vars and key is None:
+                    key = os.getenv(variable_name)
+                    if key:
+                        logger.info(f"Using environment variable {variable_name} for table column {column_name}")
+                    else:
+                        logger.error(f"Environment variable {variable_name} is not set.")
+
+                # Update the column value with the resolved value
+                updated_row[column_name] = key if key is not None else None
+                if key is None:
+                    logger.warning(
+                        f"Could not get value for {variable_name} in table column {column_name}. Setting it to None."
+                    )
+
+            updated_table_data.append(updated_row)
+
+        params[table_field_name] = updated_table_data
+        return params
+
+
 async def update_params_with_load_from_db_fields(
     custom_component: CustomComponent,
     params,
@@ -142,27 +224,38 @@ async def update_params_with_load_from_db_fields(
             logger.debug("Loading variables from environment variables because database is not available.")
             return load_from_env_vars(params, load_from_db_fields)
         for field in load_from_db_fields:
-            if field not in params or not params[field]:
-                continue
-
-            try:
-                key = await custom_component.get_variable(name=params[field], field=field, session=session)
-            except ValueError as e:
-                if any(reason in str(e) for reason in ["User id is not set", "variable not found."]):
-                    raise
-                logger.debug(str(e))
-                key = None
-
-            if fallback_to_env_vars and key is None:
-                key = os.getenv(params[field])
-                if key:
-                    logger.info(f"Using environment variable {params[field]} for {field}")
-                else:
-                    logger.error(f"Environment variable {params[field]} is not set.")
-
-            params[field] = key if key is not None else None
-            if key is None:
-                logger.warning(f"Could not get value for {field}. Setting it to None.")
+            # Check if this is a table field (using our naming convention)
+            if field.startswith("table:"):
+                table_field_name = field[6:]  # Remove "table:" prefix
+                params = await update_table_params_with_load_from_db_fields(
+                    custom_component,
+                    params,
+                    table_field_name,
+                    fallback_to_env_vars=fallback_to_env_vars,
+                )
+            else:
+                # Handle regular field-level load_from_db
+                if field not in params or not params[field]:
+                    continue
+
+                try:
+                    key = await custom_component.get_variable(name=params[field], field=field, session=session)
+                except ValueError as e:
+                    if any(reason in str(e) for reason in ["User id is not set", "variable not found."]):
+                        raise
+                    logger.debug(str(e))
+                    key = None
+
+                if fallback_to_env_vars and key is None:
+                    key = os.getenv(params[field])
+                    if key:
+                        logger.info(f"Using environment variable {params[field]} for {field}")
+                    else:
+                        logger.error(f"Environment variable {params[field]} is not set.")
+
+                params[field] = key if key is not None else None
+                if key is None:
+                    logger.warning(f"Could not get value for {field}. Setting it to None.")
 
         return params
 

lfx/schema/image.py

@@ -23,6 +23,9 @@ def is_image_file(file_path) -> bool:
 
 def get_file_paths(files: list[str | dict]):
     """Get file paths for a list of files."""
+    if not files:
+        return []
+
     storage_service = get_storage_service()
     if not storage_service:
         # Extract paths from dicts if present
@@ -31,7 +34,12 @@ def get_file_paths(files: list[str | dict]):
         cache_dir = Path(user_cache_dir("langflow"))
 
         for file in files:
+            if not file:  # Skip empty/None files
+                continue
+
             file_path = file["path"] if isinstance(file, dict) and "path" in file else file
+            if not file_path:  # Skip empty paths
+                continue
 
             # If it's a relative path like "flow_id/filename", resolve it to cache dir
             path = Path(file_path)
@@ -52,13 +60,30 @@ def get_file_paths(files: list[str | dict]):
         # Handle dict case
         if storage_service is None:
             continue
+
+        if not file:  # Skip empty/None files
+            continue
+
         if isinstance(file, dict) and "path" in file:
-            file_path = Path(file["path"])
+            file_path_str = file["path"]
         elif hasattr(file, "path") and file.path:
-            file_path = Path(file.path)
+            file_path_str = file.path
         else:
-            file_path = Path(file)
-        flow_id, file_name = str(file_path.parent), file_path.name
+            file_path_str = file
+
+        if not file_path_str:  # Skip empty paths
+            continue
+
+        file_path = Path(file_path_str)
+        # Handle edge case where path might be just a filename without parent
+        if file_path.parent == Path():
+            flow_id, file_name = "", file_path.name
+        else:
+            flow_id, file_name = str(file_path.parent), file_path.name
+
+        if not file_name:  # Skip if no filename
+            continue
+
         file_paths.append(storage_service.build_full_path(flow_id=flow_id, file_name=file_name))
     return file_paths
 
@@ -69,22 +94,31 @@ async def get_files(
     convert_to_base64: bool = False,
 ):
     """Get files from storage service."""
+    if not file_paths:
+        return []
+
     storage_service = get_storage_service()
     if not storage_service:
         # For testing purposes, read files directly when no storage service
         file_objects: list[str | bytes] = []
         for file_path_str in file_paths:
+            if not file_path_str:  # Skip empty paths
+                continue
+
             file_path = Path(file_path_str)
             if file_path.exists():
                 # Use async read for compatibility
-
-                async with aiofiles.open(file_path, "rb") as f:
-                    file_content = await f.read()
-                if convert_to_base64:
-                    file_base64 = base64.b64encode(file_content).decode("utf-8")
-                    file_objects.append(file_base64)
-                else:
-                    file_objects.append(file_content)
+                try:
+                    async with aiofiles.open(file_path, "rb") as f:
+                        file_content = await f.read()
+                    if convert_to_base64:
+                        file_base64 = base64.b64encode(file_content).decode("utf-8")
+                        file_objects.append(file_base64)
+                    else:
+                        file_objects.append(file_content)
+                except Exception as e:
+                    msg = f"Error reading file {file_path}: {e}"
+                    raise FileNotFoundError(msg) from e
             else:
                 msg = f"File not found: {file_path}"
                 raise FileNotFoundError(msg)
@@ -92,16 +126,32 @@ async def get_files(
 
     file_objects: list[str | bytes] = []
     for file in file_paths:
+        if not file:  # Skip empty file paths
+            continue
+
         file_path = Path(file)
-        flow_id, file_name = str(file_path.parent), file_path.name
+        # Handle edge case where path might be just a filename without parent
+        if file_path.parent == Path():
+            flow_id, file_name = "", file_path.name
+        else:
+            flow_id, file_name = str(file_path.parent), file_path.name
+
+        if not file_name:  # Skip if no filename
+            continue
+
         if not storage_service:
             continue
-        file_object = await storage_service.get_file(flow_id=flow_id, file_name=file_name)
-        if convert_to_base64:
-            file_base64 = base64.b64encode(file_object).decode("utf-8")
-            file_objects.append(file_base64)
-        else:
-            file_objects.append(file_object)
+
+        try:
+            file_object = await storage_service.get_file(flow_id=flow_id, file_name=file_name)
+            if convert_to_base64:
+                file_base64 = base64.b64encode(file_object).decode("utf-8")
+                file_objects.append(file_base64)
+            else:
+                file_objects.append(file_object)
+        except Exception as e:
+            msg = f"Error getting file {file} from storage: {e}"
+            raise FileNotFoundError(msg) from e
     return file_objects
 
 
@@ -115,6 +165,9 @@ class Image(BaseModel):
         """Convert image to base64 string."""
         if self.path:
             files = get_files([self.path], convert_to_base64=True)
+            if not files:
+                msg = f"No files found or file could not be converted to base64: {self.path}"
+                raise ValueError(msg)
             return files[0]
         msg = "Image path is not set."
         raise ValueError(msg)

lfx/schema/message.py

@@ -139,7 +139,8 @@ class Message(Data):
         if self.sender == MESSAGE_SENDER_USER or not self.sender:
             if self.files:
                 contents = [{"type": "text", "text": text}]
-                contents.extend(self.get_file_content_dicts())
+                file_contents = self.get_file_content_dicts()
+                contents.extend(file_contents)
                 human_message = HumanMessage(content=contents)
             else:
                 human_message = HumanMessage(content=text)
@@ -198,7 +199,11 @@ class Message(Data):
     # Keep this async method for backwards compatibility
     def get_file_content_dicts(self):
         content_dicts = []
-        files = get_file_paths(self.files)
+        try:
+            files = get_file_paths(self.files)
+        except Exception as e:  # noqa: BLE001
+            logger.error(f"Error getting file paths: {e}")
+            return content_dicts
 
         for file in files:
             if isinstance(file, Image):

lfx/schema/table.py

@@ -44,6 +44,8 @@ class Column(BaseModel):
     disable_edit: bool = Field(default=False)
     edit_mode: EditMode | None = Field(default=EditMode.POPOVER)
     hidden: bool = Field(default=False)
+    load_from_db: bool = Field(default=False)
+    """Whether this column's default value should be loaded from global variables"""
 
     @model_validator(mode="after")
     def set_display_name(self):

lfx/services/settings/base.py

@@ -226,6 +226,10 @@ class Settings(BaseSettings):
     """The host on which Langflow will run."""
     port: int = 7860
     """The port on which Langflow will run."""
+    runtime_port: int | None = Field(default=None, exclude=True)
+    """TEMPORARY: The port detected at runtime after checking for conflicts.
+    This field is system-managed only and will be removed in future versions
+    when strict port enforcement is implemented (errors will be raised if port unavailable)."""
     workers: int = 1
     """The number of workers to run."""
     log_level: str = "critical"
@@ -275,6 +279,9 @@ class Settings(BaseSettings):
     mcp_server_enable_progress_notifications: bool = False
     """If set to False, Langflow will not send progress notifications in the MCP server."""
 
+    # Add projects to MCP servers automatically on creation
+    add_projects_to_mcp_servers: bool = True
+    """If set to True, newly created projects will be added to the user's MCP servers config automatically."""
     # MCP Composer
     mcp_composer_enabled: bool = True
     """If set to False, Langflow will not start the MCP Composer service."""

lfx/utils/util.py

@@ -2,6 +2,7 @@ import difflib
 import importlib
 import inspect
 import json
+import os
 import re
 from functools import wraps
 from pathlib import Path
@@ -16,6 +17,140 @@ from lfx.template.frontend_node.constants import FORCE_SHOW_FIELDS
 from lfx.utils import constants
 
 
+def detect_container_environment() -> str | None:
+    """Detect if running in a container and return the appropriate container type.
+
+    Returns:
+        'docker' if running in Docker, 'podman' if running in Podman, None otherwise.
+    """
+    # Check for .dockerenv file (Docker)
+    if Path("/.dockerenv").exists():
+        return "docker"
+
+    # Check cgroup for container indicators
+    try:
+        with Path("/proc/self/cgroup").open() as f:
+            content = f.read()
+            if "docker" in content:
+                return "docker"
+            if "podman" in content:
+                return "podman"
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    # Check environment variables (lowercase 'container' is the standard for Podman)
+    if os.getenv("container") == "podman":  # noqa: SIM112
+        return "podman"
+
+    return None
+
+
+def get_container_host() -> str | None:
+    """Get the hostname to access host services from within a container.
+
+    Tries multiple methods to find the correct hostname:
+    1. host.containers.internal (Podman) or host.docker.internal (Docker)
+    2. Gateway IP from routing table (fallback for Linux)
+
+    Returns:
+        The hostname or IP to use, or None if not in a container.
+    """
+    import socket
+
+    # Check if we're in a container first
+    container_type = detect_container_environment()
+    if not container_type:
+        return None
+
+    # Try container-specific hostnames first based on detected type
+    if container_type == "podman":
+        # Podman: try host.containers.internal first
+        try:
+            socket.getaddrinfo("host.containers.internal", None)
+        except socket.gaierror:
+            pass
+        else:
+            return "host.containers.internal"
+
+        # Fallback to host.docker.internal (for Podman Desktop on macOS)
+        try:
+            socket.getaddrinfo("host.docker.internal", None)
+        except socket.gaierror:
+            pass
+        else:
+            return "host.docker.internal"
+    else:
+        # Docker: try host.docker.internal first
+        try:
+            socket.getaddrinfo("host.docker.internal", None)
+        except socket.gaierror:
+            pass
+        else:
+            return "host.docker.internal"
+
+        # Fallback to host.containers.internal (unlikely but possible)
+        try:
+            socket.getaddrinfo("host.containers.internal", None)
+        except socket.gaierror:
+            pass
+        else:
+            return "host.containers.internal"
+
+    # Fallback: try to get gateway IP from routing table (Linux containers)
+    try:
+        with Path("/proc/net/route").open() as f:
+            for line in f:
+                fields = line.strip().split()
+                min_field_count = 3  # Minimum fields needed: interface, destination, gateway
+                if len(fields) >= min_field_count and fields[1] == "00000000":  # Default route
+                    # Gateway is in hex format (little-endian)
+                    gateway_hex = fields[2]
+                    # Convert hex to IP address
+                    # The hex is in little-endian format, so we read it backwards in pairs
+                    octets = [gateway_hex[i : i + 2] for i in range(0, 8, 2)]
+                    return ".".join(str(int(octet, 16)) for octet in reversed(octets))
+    except (FileNotFoundError, PermissionError, IndexError, ValueError):
+        pass
+
+    return None
+
+
+def transform_localhost_url(url: str) -> str:
+    """Transform localhost URLs to container-accessible hosts when running in a container.
+
+    Automatically detects if running inside a container and finds the appropriate host
+    address to replace localhost/127.0.0.1. Tries in order:
+    - host.docker.internal (if resolvable)
+    - host.containers.internal (if resolvable)
+    - Gateway IP from routing table (fallback)
+
+    Args:
+        url: The original URL
+
+    Returns:
+        Transformed URL with container-accessible host if applicable, otherwise the original URL.
+
+    Example:
+        >>> transform_localhost_url("http://localhost:5001")
+        # Returns "http://host.docker.internal:5001" if running in Docker and hostname resolves
+        # Returns "http://172.17.0.1:5001" if running in Docker on Linux (gateway IP fallback)
+        # Returns "http://localhost:5001" if not in a container
+    """
+    container_host = get_container_host()
+
+    if not container_host:
+        return url
+
+    # Replace localhost and 127.0.0.1 with the container host
+    localhost_patterns = ["localhost", "127.0.0.1"]
+
+    for pattern in localhost_patterns:
+        if pattern in url:
+            return url.replace(pattern, container_host)
+
+    return url
+
+
 def unescape_string(s: str):
     # Replace escaped new line characters with actual new line characters
     return s.replace("\\n", "\n")

{lfx_nightly-0.1.12.dev26.dist-info → lfx_nightly-0.1.12.dev28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev26
+Version: 0.1.12.dev28
 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