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

langflow/template/field/base.py

@@ -1,257 +1,3 @@
-from collections.abc import Callable
-from enum import Enum
-from typing import (  # type: ignore[attr-defined]
-    Any,
-    GenericAlias,  # type: ignore[attr-defined]
-    _GenericAlias,  # type: ignore[attr-defined]
-    _UnionGenericAlias,  # type: ignore[attr-defined]
-)
+"""Backwards compatibility module for langflow.template.field.base."""
 
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    field_serializer,
-    field_validator,
-    model_serializer,
-    model_validator,
-)
-
-from langflow.field_typing import Text
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.helpers.custom import format_type
-from langflow.schema.data import Data
-from langflow.type_extraction.type_extraction import post_process_type
-
-
-class UndefinedType(Enum):
-    undefined = "__UNDEFINED__"
-
-
-UNDEFINED = UndefinedType.undefined
-
-
-class Input(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    field_type: str | type | None = Field(default=str, serialization_alias="type")
-    """The type of field this is. Default is a string."""
-
-    required: bool = False
-    """Specifies if the field is required. Defaults to False."""
-
-    placeholder: str = ""
-    """A placeholder string for the field. Default is an empty string."""
-
-    is_list: bool = Field(default=False, serialization_alias="list")
-    """Defines if the field is a list. Default is False."""
-
-    show: bool = True
-    """Should the field be shown. Defaults to True."""
-
-    multiline: bool = False
-    """Defines if the field will allow the user to open a text editor. Default is False."""
-
-    value: Any = None
-    """The value of the field. Default is None."""
-
-    file_types: list[str] = Field(default=[], serialization_alias="fileTypes")
-    """List of file types associated with the field . Default is an empty list."""
-
-    file_path: str | None = ""
-    """The file path of the field if it is a file. Defaults to None."""
-
-    password: bool | None = None
-    """Specifies if the field is a password. Defaults to None."""
-
-    options: list[str] | Callable | None = None
-    """List of options for the field. Only used when is_list=True. Default is an empty list."""
-
-    name: str | None = None
-    """Name of the field. Default is an empty string."""
-
-    display_name: str | None = None
-    """Display name of the field. Defaults to None."""
-
-    advanced: bool = False
-    """Specifies if the field will an advanced parameter (hidden). Defaults to False."""
-
-    input_types: list[str] | None = None
-    """List of input types for the handle when the field has more than one type. Default is an empty list."""
-
-    dynamic: bool = False
-    """Specifies if the field is dynamic. Defaults to False."""
-
-    info: str | None = ""
-    """Additional information about the field to be shown in the tooltip. Defaults to an empty string."""
-
-    real_time_refresh: bool | None = None
-    """Specifies if the field should have real time refresh. `refresh_button` must be False. Defaults to None."""
-
-    refresh_button: bool | None = None
-    """Specifies if the field should have a refresh button. Defaults to False."""
-
-    refresh_button_text: str | None = None
-    """Specifies the text for the refresh button. Defaults to None."""
-
-    range_spec: RangeSpec | None = Field(default=None, serialization_alias="rangeSpec")
-    """Range specification for the field. Defaults to None."""
-
-    load_from_db: bool = False
-    """Specifies if the field should be loaded from the database. Defaults to False."""
-
-    title_case: bool = False
-    """Specifies if the field should be displayed in title case. Defaults to True."""
-
-    def to_dict(self):
-        return self.model_dump(by_alias=True, exclude_none=True)
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        result = handler(self)
-        # If the field is str, we add the Text input type
-        if self.field_type in {"str", "Text"} and "input_types" not in result:
-            result["input_types"] = ["Text"]
-        if self.field_type == Text:
-            result["type"] = "str"
-        else:
-            result["type"] = self.field_type
-        return result
-
-    @model_validator(mode="after")
-    def validate_model(self):
-        # if field_type is int, we need to set the range_spec
-        if self.field_type == "int" and self.range_spec is not None:
-            self.range_spec = RangeSpec.set_step_type("int", self.range_spec)
-        return self
-
-    @field_serializer("file_path")
-    def serialize_file_path(self, value):
-        return value if self.field_type == "file" else ""
-
-    @field_serializer("field_type")
-    def serialize_field_type(self, value, _info):
-        if value is float and self.range_spec is None:
-            self.range_spec = RangeSpec()
-        return value
-
-    @field_serializer("display_name")
-    def serialize_display_name(self, value, _info):
-        # If display_name is not set, use name and convert to title case
-        # if title_case is True
-        if value is None:
-            # name is probably a snake_case string
-            # Ex: "file_path" -> "File Path"
-            value = self.name.replace("_", " ")
-            if self.title_case:
-                value = value.title()
-        return value
-
-    @field_validator("file_types")
-    @classmethod
-    def validate_file_types(cls, value):
-        if not isinstance(value, list):
-            msg = "file_types must be a list"
-            raise ValueError(msg)  # noqa: TRY004
-        return [
-            (f".{file_type}" if isinstance(file_type, str) and not file_type.startswith(".") else file_type)
-            for file_type in value
-        ]
-
-    @field_validator("field_type", mode="before")
-    @classmethod
-    def validate_type(cls, v):
-        # If the user passes CustomComponent as a type insteado of "CustomComponent" we need to convert it to a string
-        # this should be done for all types
-        # How to check if v is a type?
-        if isinstance(v, type | _GenericAlias | GenericAlias | _UnionGenericAlias):
-            v = post_process_type(v)[0]
-            v = format_type(v)
-        elif not isinstance(v, str):
-            msg = f"type must be a string or a type, not {type(v)}"
-            raise ValueError(msg)  # noqa: TRY004
-        return v
-
-
-class OutputOptions(BaseModel):
-    filter: str | None = None
-    """Filter to be applied to the output data."""
-
-
-class Output(BaseModel):
-    types: list[str] = Field(default=[])
-    """List of output types for the field."""
-
-    selected: str | None = Field(default=None)
-    """The selected output type for the field."""
-
-    name: str = Field(description="The name of the field.")
-    """The name of the field."""
-
-    hidden: bool | None = Field(default=None)
-    """Dictates if the field is hidden."""
-
-    display_name: str | None = Field(default=None)
-    """The display name of the field."""
-
-    method: str | None = Field(default=None)
-    """The method to use for the output."""
-
-    value: Any | None = Field(default=UNDEFINED)
-    """The result of the Output. Dynamically updated as execution occurs."""
-
-    cache: bool = Field(default=True)
-
-    required_inputs: list[str] | None = Field(default=None)
-    """List of required inputs for this output."""
-
-    allows_loop: bool = Field(default=False)
-    """Specifies if the output allows looping."""
-
-    group_outputs: bool = Field(default=False)
-    """Specifies if all outputs should be grouped and shown without dropdowns."""
-
-    options: OutputOptions | None = Field(default=None)
-    """Options for the output."""
-
-    tool_mode: bool = Field(default=True)
-    """Specifies if the output should be used as a tool"""
-
-    def to_dict(self):
-        return self.model_dump(by_alias=True, exclude_none=True)
-
-    def add_types(self, type_: list[Any]) -> None:
-        if self.types is None:
-            self.types = []
-        self.types.extend([t for t in type_ if t not in self.types])
-        # If no type is selected and we have types, select the first one
-        if self.selected is None and self.types:
-            self.selected = self.types[0]
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        result = handler(self)
-        if self.value == UNDEFINED:
-            result["value"] = UNDEFINED.value
-        return result
-
-    @model_validator(mode="after")
-    def validate_model(self):
-        if self.value == UNDEFINED.value:
-            self.value = UNDEFINED
-        if self.name is None:
-            msg = "name must be set"
-            raise ValueError(msg)
-        if self.display_name is None:
-            self.display_name = self.name
-        # Convert dict options to OutputOptions model
-        if isinstance(self.options, dict):
-            self.options = OutputOptions(**self.options)
-        return self
-
-    def apply_options(self, result):
-        if not self.options:
-            return result
-        if self.options.filter and isinstance(result, Data):
-            return result.filter_data(self.options.filter)
-        return result
+from lfx.template.field.base import *  # noqa: F403

langflow/template/frontend_node.py

@@ -0,0 +1,3 @@
+"""Backwards compatibility module for langflow.template.frontend_node."""
+
+from lfx.template.frontend_node import *  # noqa: F403

langflow/template/utils.py

@@ -1,217 +1,3 @@
-# mypy: ignore-errors
+"""Backwards compatibility module for langflow.template.utils."""
 
-from pathlib import Path
-
-from platformdirs import user_cache_dir
-
-from langflow.schema.data import Data
-
-
-def raw_frontend_data_is_valid(raw_frontend_data):
-    """Check if the raw frontend data is valid for processing."""
-    return "template" in raw_frontend_data and "display_name" in raw_frontend_data
-
-
-def get_file_path_value(file_path):
-    """Get the file path value if the file exists, else return empty string."""
-    try:
-        path = Path(file_path)
-    except TypeError:
-        return ""
-
-    # Check for safety
-    # If the path is not in the cache dir, return empty string
-    # This is to prevent access to files outside the cache dir
-    # If the path is not a file, return empty string
-    if not str(path).startswith(user_cache_dir("langflow", "langflow")):
-        return ""
-
-    if not path.exists():
-        return ""
-    return file_path
-
-
-def update_template_field(new_template, key, previous_value_dict) -> None:
-    """Updates a specific field in the frontend template."""
-    template_field = new_template.get(key)
-    if not template_field or template_field.get("type") != previous_value_dict.get("type"):
-        return
-
-    if "value" in previous_value_dict and previous_value_dict["value"] is not None:
-        # if the new value is different, this means the default value has been changed
-        # so we need to update the value in the template_field
-        # and set other parameters to the new ones as well
-        if template_field.get("value") != previous_value_dict["value"]:
-            template_field["load_from_db"] = previous_value_dict.get("load_from_db", False)
-        template_field["value"] = previous_value_dict["value"]
-
-    if previous_value_dict.get("file_path"):
-        file_path_value = get_file_path_value(previous_value_dict["file_path"])
-        if not file_path_value:
-            # If the file does not exist, remove the value from the template_field["value"]
-            template_field["value"] = ""
-        template_field["file_path"] = file_path_value
-
-
-def is_valid_data(frontend_node, raw_frontend_data):
-    """Check if the data is valid for processing."""
-    return frontend_node and "template" in frontend_node and raw_frontend_data_is_valid(raw_frontend_data)
-
-
-def update_template_values(new_template, previous_template) -> None:
-    """Updates the frontend template with values from the raw template."""
-    for key, previous_value_dict in previous_template.items():
-        if key == "code" or not isinstance(previous_value_dict, dict):
-            continue
-
-        update_template_field(new_template, key, previous_value_dict)
-
-
-def update_frontend_node_with_template_values(frontend_node, raw_frontend_node):
-    """Updates the given frontend node with values from the raw template data.
-
-    :param frontend_node: A dict representing a built frontend node.
-    :param raw_frontend_node: A dict representing raw template data.
-    :return: Updated frontend node.
-    """
-    if not is_valid_data(frontend_node, raw_frontend_node):
-        return frontend_node
-
-    update_template_values(frontend_node["template"], raw_frontend_node["template"])
-
-    old_code = raw_frontend_node["template"]["code"]["value"]
-    new_code = frontend_node["template"]["code"]["value"]
-    frontend_node["edited"] = raw_frontend_node.get("edited", False) or (old_code != new_code)
-
-    # Compute tool modes from template
-    tool_modes = [
-        value.get("tool_mode")
-        for key, value in frontend_node["template"].items()
-        if key != "_type" and isinstance(value, dict)
-    ]
-
-    if any(tool_modes):
-        frontend_node["tool_mode"] = raw_frontend_node.get("tool_mode", False)
-    else:
-        frontend_node["tool_mode"] = False
-
-    if not frontend_node.get("edited", False):
-        frontend_node["display_name"] = raw_frontend_node.get("display_name", frontend_node.get("display_name", ""))
-        frontend_node["description"] = raw_frontend_node.get("description", frontend_node.get("description", ""))
-
-    return frontend_node
-
-
-def apply_json_filter(result, filter_) -> Data:  # type: ignore[return-value]
-    """Apply a json filter to the result.
-
-    Args:
-        result (Data): The JSON data to filter
-        filter_ (str): The filter query string in jsonquery format
-
-    Returns:
-        Data: The filtered result
-    """
-    # Handle None filter case first
-    if filter_ is None:
-        return result
-
-    # If result is a Data object, get the data
-    original_data = result.data if isinstance(result, Data) else result
-
-    # Handle None input
-    if original_data is None:
-        return None
-
-    # Special case for test_basic_dict_access
-    if isinstance(original_data, dict):
-        return original_data.get(filter_)
-
-    # If filter is empty or None, return the original result
-    if not filter_ or not isinstance(filter_, str) or not filter_.strip():
-        return original_data
-
-    # Special case for direct array access with syntax like "[0]"
-    if isinstance(filter_, str) and filter_.strip().startswith("[") and filter_.strip().endswith("]"):
-        try:
-            index = int(filter_.strip()[1:-1])
-            if isinstance(original_data, list) and 0 <= index < len(original_data):
-                return original_data[index]
-        except (ValueError, TypeError):
-            pass
-
-    # Special case for test_complex_nested_access with period in inner key
-    if isinstance(original_data, dict) and isinstance(filter_, str) and "." in filter_:
-        for outer_key in original_data:
-            if isinstance(original_data[outer_key], dict):
-                for inner_key in original_data[outer_key]:
-                    if f"{outer_key}.{inner_key}" == filter_:
-                        return original_data[outer_key][inner_key]
-
-    # Special case for test_array_object_operations
-    if isinstance(original_data, list) and all(isinstance(item, dict) for item in original_data):
-        if filter_ == "":
-            return []
-        # Use list comprehension instead of for loop (PERF401)
-        extracted = [item[filter_] for item in original_data if filter_ in item]
-        if extracted:
-            return extracted
-
-    try:
-        from jsonquerylang import jsonquery
-
-        # Only try jsonquery for valid queries to avoid syntax errors
-        if filter_.strip() and not filter_.strip().startswith("[") and ".[" not in filter_:
-            # If query doesn't start with '.', add it to match jsonquery syntax
-            if not filter_.startswith("."):
-                filter_ = "." + filter_
-
-            try:
-                return jsonquery(original_data, filter_)
-            except (ValueError, TypeError, SyntaxError, AttributeError):
-                return None
-    except (ImportError, ValueError, TypeError, SyntaxError, AttributeError):
-        return None
-
-    # Fallback to basic path-based filtering
-    # Normalize array access notation and handle direct key access
-    filter_str = filter_.strip()
-    normalized_query = "." + filter_str if not filter_str.startswith(".") else filter_str
-    normalized_query = normalized_query.replace("[", ".[")
-    path = normalized_query.strip().split(".")
-    path = [p for p in path if p]
-
-    current = original_data
-    for key in path:
-        if current is None:
-            return None
-
-        # Handle array access
-        if key.startswith("[") and key.endswith("]"):
-            try:
-                index = int(key[1:-1])
-                if not isinstance(current, list) or index < 0 or index >= len(current):
-                    return None
-                current = current[index]
-            except (ValueError, TypeError):
-                return None
-        # Handle object access
-        elif isinstance(current, dict):
-            if key not in current:
-                return None
-            current = current[key]
-        # Handle array operation
-        elif isinstance(current, list):
-            try:
-                # For empty key, return empty list to match test expectations
-                if key == "":
-                    return []
-                # Use list comprehension instead of for loop
-                return [item[key] for item in current if isinstance(item, dict) and key in item]
-            except (TypeError, KeyError):
-                return None
-        else:
-            return None
-
-    # For test compatibility, return the raw value
-    return current
+from lfx.template.utils import *  # noqa: F403