lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/inputs/inputs.py

@@ -22,6 +22,7 @@ from .input_mixin import (
     LinkMixin,
     ListableInputMixin,
     MetadataTraceMixin,
+    ModelInputMixin,
     MultilineMixin,
     QueryMixin,
     RangeMixin,
@@ -119,10 +120,127 @@ class PromptInput(BaseInputMixin, ListableInputMixin, InputTraceMixin, ToolModeM
     field_type: SerializableFieldTypes = FieldTypes.PROMPT
 
 
+class MustachePromptInput(PromptInput):
+    field_type: SerializableFieldTypes = FieldTypes.MUSTACHE_PROMPT
+
+
 class CodeInput(BaseInputMixin, ListableInputMixin, InputTraceMixin, ToolModeMixin):
     field_type: SerializableFieldTypes = FieldTypes.CODE
 
 
+class ModelInput(BaseInputMixin, ModelInputMixin, ListableInputMixin, InputTraceMixin, ToolModeMixin):
+    """Represents a model input field with optional LanguageModel connection support.
+
+    By default:
+    - input_types=[] (no handle shown)
+    - external_options with "Connect other models" button
+    - refresh_button=True
+
+    When "Connect other models" is selected (value="connect_other_models"):
+    - input_types is set to ["LanguageModel"] to show the connection handle
+
+    Value format:
+    - Can be a list of dicts: [{'name': 'gpt-4o', 'provider': 'OpenAI', ...}]
+    - Can be a simple list of strings: ['gpt-4o', 'gpt-4o-mini'] (auto-converted)
+    - Can be a single string: 'gpt-4o' (auto-converted to list)
+    - Can be "connect_other_models" string to enable connection mode
+    """
+
+    field_type: SerializableFieldTypes = FieldTypes.MODEL
+    placeholder: str | None = "Setup Provider"
+    input_types: list[str] = Field(default_factory=list)  # Empty by default, no handle shown
+    refresh_button: bool | None = True
+    external_options: dict = Field(
+        default_factory=lambda: {
+            "fields": {
+                "data": {
+                    "node": {
+                        "name": "connect_other_models",
+                        "display_name": "Connect other models",
+                        "icon": "CornerDownLeft",
+                    }
+                }
+            },
+        }
+    )
+
+    @field_validator("value", mode="before")
+    @classmethod
+    def normalize_value(cls, v):
+        """Convert simple string or list of strings to list of dicts format.
+
+        Allows passing:
+        - 'gpt-4o' -> [{'name': 'gpt-4o', ...}]
+        - ['gpt-4o', 'claude-3'] -> [{'name': 'gpt-4o', ...}, {'name': 'claude-3', ...}]
+        - [{'name': 'gpt-4o'}] -> [{'name': 'gpt-4o'}] (unchanged)
+        - 'connect_other_models' -> 'connect_other_models' (special value, keep as string)
+        """
+        # Handle empty or None values
+        if v is None or v == "":
+            return v
+
+        # Special case: keep "connect_other_models" as a string to enable connection mode
+        if v == "connect_other_models":
+            return v
+
+        # If it's not a list or string, return as-is (could be a BaseLanguageModel)
+        if not isinstance(v, list | str):
+            return v
+
+        # If it's a list and already in dict format, return as-is
+        if isinstance(v, list) and all(isinstance(item, dict) for item in v):
+            return v
+
+        # If it's a string or list of strings, convert to dict format
+        if isinstance(v, str) or (isinstance(v, list) and all(isinstance(item, str) for item in v)):
+            # Avoid circular import by importing the module directly (not through package __init__)
+            try:
+                from lfx.base.models.unified_models import normalize_model_names_to_dicts
+
+                return normalize_model_names_to_dicts(v)
+            except Exception:  # noqa: BLE001
+                # Fallback if import or normalization fails
+                # This can happen during module initialization or in test environments
+                if isinstance(v, str):
+                    return [{"name": v}]
+                return [{"name": item} for item in v]
+
+        # Return as-is for all other cases
+        return v
+
+    @model_validator(mode="after")
+    def set_defaults(self):
+        """Handle connection mode and set defaults.
+
+        When value is "connect_other_models", set input_types to ["LanguageModel"]
+        to enable the connection handle. Otherwise, keep input_types empty.
+        """
+        # Check if we're in connection mode (user selected "Connect other models")
+        if self.value == "connect_other_models" and not self.input_types:
+            # Enable connection handle by setting input_types
+            # Use object.__setattr__ to avoid triggering validation recursion
+            object.__setattr__(self, "input_types", ["LanguageModel"])
+
+        # Set external_options if not explicitly provided
+        if self.external_options is None or len(self.external_options) == 0:
+            object.__setattr__(
+                self,
+                "external_options",
+                {
+                    "fields": {
+                        "data": {
+                            "node": {
+                                "name": "connect_other_models",
+                                "display_name": "Connect other models",
+                                "icon": "CornerDownLeft",
+                            }
+                        }
+                    },
+                },
+            )
+        return self
+
+
 # Applying mixins to a specific input type
 class StrInput(
     BaseInputMixin,
@@ -687,11 +805,13 @@ InputTypes: TypeAlias = (
     | HandleInput
     | IntInput
     | McpInput
+    | ModelInput
     | MultilineInput
     | MultilineSecretInput
     | NestedDictInput
     | ToolsInput
     | PromptInput
+    | MustachePromptInput
     | CodeInput
     | SecretStrInput
     | StrInput

lfx/interface/components.py

@@ -14,11 +14,16 @@ import orjson
 from lfx.constants import BASE_COMPONENTS_PATH
 from lfx.custom.utils import abuild_custom_components, create_component_template
 from lfx.log.logger import logger
+from lfx.utils.validate_cloud import (
+    filter_disabled_components_from_dict,
+    is_component_disabled_in_astra_cloud,
+)
 
 if TYPE_CHECKING:
     from lfx.services.settings.service import SettingsService
 
 MIN_MODULE_PARTS = 2
+MIN_MODULE_PARTS_WITH_FILENAME = 4  # Minimum parts needed to have a module filename (lfx.components.type.filename)
 EXPECTED_RESULT_LENGTH = 2  # Expected length of the tuple returned by _process_single_module
 
 
@@ -284,6 +289,8 @@ async def _load_from_index_or_cache(
             if top_level not in modules_dict:
                 modules_dict[top_level] = {}
             modules_dict[top_level].update(components)
+        # Filter disabled components for Astra cloud
+        modules_dict = filter_disabled_components_from_dict(modules_dict)
         await logger.adebug(f"Loaded {len(modules_dict)} component categories from index")
         return modules_dict, "builtin"
 
@@ -303,6 +310,8 @@ async def _load_from_index_or_cache(
                     if top_level not in modules_dict:
                         modules_dict[top_level] = {}
                     modules_dict[top_level].update(components)
+                # Filter disabled components for Astra cloud
+                modules_dict = filter_disabled_components_from_dict(modules_dict)
                 await logger.adebug(f"Loaded {len(modules_dict)} component categories from cache")
                 return modules_dict, "cache"
 
@@ -335,11 +344,19 @@ async def _load_components_dynamically(
         if "deactivated" in modname:
             continue
 
-        # If specific modules requested, filter by top-level module name
-        if target_modules:
-            # Extract top-level: "lfx.components.mistral.xyz" -> "mistral"
-            parts = modname.split(".")
-            if len(parts) > MIN_MODULE_PARTS and parts[2].lower() not in target_modules:
+        # Parse module name once for all checks
+        parts = modname.split(".")
+        if len(parts) > MIN_MODULE_PARTS:
+            component_type = parts[2]
+
+            # Skip disabled components when ASTRA_CLOUD_DISABLE_COMPONENT is true
+            if len(parts) >= MIN_MODULE_PARTS_WITH_FILENAME:
+                module_filename = parts[3]
+                if is_component_disabled_in_astra_cloud(component_type.lower(), module_filename):
+                    continue
+
+            # If specific modules requested, filter by top-level module name
+            if target_modules and component_type.lower() not in target_modules:
                 continue
 
         module_names.append(modname)
@@ -549,7 +566,7 @@ def _process_single_module(modname: str) -> tuple[str, dict] | None:
     return (top_level, module_components)
 
 
-async def _determine_loading_strategy(settings_service: "SettingsService") -> dict:
+async def _determine_loading_strategy(settings_service: "SettingsService") -> dict[str, Any]:
     """Determines and executes the appropriate component loading strategy.
 
     Args:
@@ -577,7 +594,7 @@ async def _determine_loading_strategy(settings_service: "SettingsService") -> di
             f"Built {component_count} custom components from {settings_service.settings.components_path}"
         )
 
-    return component_cache.all_types_dict
+    return component_cache.all_types_dict or {}
 
 
 async def get_and_cache_all_types_dict(

lfx/interface/initialize/loading.py

@@ -111,15 +111,26 @@ def convert_kwargs(params):
     return params
 
 
-def load_from_env_vars(params, load_from_db_fields):
+def load_from_env_vars(params, load_from_db_fields, context=None):
     for field in load_from_db_fields:
         if field not in params or not params[field]:
             continue
-        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.")
+        variable_name = params[field]
+        key = None
+
+        # Check request_variables in context
+        if context and "request_variables" in context:
+            request_variables = context["request_variables"]
+            if variable_name in request_variables:
+                key = request_variables[variable_name]
+                logger.debug(f"Found context override for variable '{variable_name}'")
+
+        if key is None:
+            key = os.getenv(variable_name)
+            if key:
+                logger.info(f"Using environment variable {variable_name} for {field}")
+            else:
+                logger.error(f"Environment variable {variable_name} 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.")
@@ -142,6 +153,11 @@ async def update_table_params_with_load_from_db_fields(
     if not table_data or not load_from_db_columns:
         return params
 
+    # Extract context once for use throughout the function
+    context = None
+    if hasattr(custom_component, "graph") and hasattr(custom_component.graph, "context"):
+        context = custom_component.graph.context
+
     async with session_scope() as session:
         settings_service = get_settings_service()
         is_noop_session = isinstance(session, NoopSession) or (
@@ -170,11 +186,22 @@ async def update_table_params_with_load_from_db_fields(
                 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.")
+                        key = None
+                        # Check request_variables first
+                        if context and "request_variables" in context:
+                            request_variables = context["request_variables"]
+                            if variable_name in request_variables:
+                                key = request_variables[variable_name]
+                                logger.debug(f"Found context override for variable '{variable_name}'")
+
+                        if 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.")
                     else:
                         # Load from database
                         key = await custom_component.get_variable(
@@ -222,7 +249,10 @@ async def update_params_with_load_from_db_fields(
         )
         if is_noop_session:
             logger.debug("Loading variables from environment variables because database is not available.")
-            return load_from_env_vars(params, load_from_db_fields)
+            context = None
+            if hasattr(custom_component, "graph") and hasattr(custom_component.graph, "context"):
+                context = custom_component.graph.context
+            return load_from_env_vars(params, load_from_db_fields, context=context)
         for field in load_from_db_fields:
             # Check if this is a table field (using our naming convention)
             if field.startswith("table:"):

lfx/io/__init__.py

@@ -14,6 +14,7 @@ from lfx.inputs import (
     McpInput,
     MessageInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     MultilineSecretInput,
     MultiselectInput,
@@ -47,6 +48,7 @@ __all__ = [
     "McpInput",
     "MessageInput",
     "MessageTextInput",
+    "ModelInput",
     "MultilineInput",
     "MultilineSecretInput",
     "MultiselectInput",

lfx/run/__init__.py

@@ -0,0 +1,5 @@
+"""Run module for executing Langflow graphs."""
+
+from lfx.run.base import RunError, run_flow
+
+__all__ = ["RunError", "run_flow"]