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

langflow/base/data/utils.py

@@ -1,198 +1,3 @@
-import unicodedata
-from collections.abc import Callable
-from concurrent import futures
-from pathlib import Path
+"""Backwards compatibility module for langflow.base.data.utils."""
 
-import chardet
-import orjson
-import yaml
-from defusedxml import ElementTree
-
-from langflow.schema.data import Data
-
-# Types of files that can be read simply by file.read()
-# and have 100% to be completely readable
-TEXT_FILE_TYPES = [
-    "txt",
-    "md",
-    "mdx",
-    "csv",
-    "json",
-    "yaml",
-    "yml",
-    "xml",
-    "html",
-    "htm",
-    "pdf",
-    "docx",
-    "py",
-    "sh",
-    "sql",
-    "js",
-    "ts",
-    "tsx",
-]
-
-IMG_FILE_TYPES = ["jpg", "jpeg", "png", "bmp", "image"]
-
-
-def normalize_text(text):
-    return unicodedata.normalize("NFKD", text)
-
-
-def is_hidden(path: Path) -> bool:
-    return path.name.startswith(".")
-
-
-def format_directory_path(path: str) -> str:
-    """Format a directory path to ensure it's properly escaped and valid.
-
-    Args:
-    path (str): The input path string.
-
-    Returns:
-    str: A properly formatted path string.
-    """
-    return path.replace("\n", "\\n")
-
-
-# Ignoring FBT001 because the DirectoryComponent in 1.0.19
-# calls this function without keyword arguments
-def retrieve_file_paths(
-    path: str,
-    load_hidden: bool,  # noqa: FBT001
-    recursive: bool,  # noqa: FBT001
-    depth: int,
-    types: list[str] = TEXT_FILE_TYPES,
-) -> list[str]:
-    path = format_directory_path(path)
-    path_obj = Path(path)
-    if not path_obj.exists() or not path_obj.is_dir():
-        msg = f"Path {path} must exist and be a directory."
-        raise ValueError(msg)
-
-    def match_types(p: Path) -> bool:
-        return any(p.suffix == f".{t}" for t in types) if types else True
-
-    def is_not_hidden(p: Path) -> bool:
-        return not is_hidden(p) or load_hidden
-
-    def walk_level(directory: Path, max_depth: int):
-        directory = directory.resolve()
-        prefix_length = len(directory.parts)
-        for p in directory.rglob("*" if recursive else "[!.]*"):
-            if len(p.parts) - prefix_length <= max_depth:
-                yield p
-
-    glob = "**/*" if recursive else "*"
-    paths = walk_level(path_obj, depth) if depth else path_obj.glob(glob)
-    return [str(p) for p in paths if p.is_file() and match_types(p) and is_not_hidden(p)]
-
-
-def partition_file_to_data(file_path: str, *, silent_errors: bool) -> Data | None:
-    # Use the partition function to load the file
-    from unstructured.partition.auto import partition
-
-    try:
-        elements = partition(file_path)
-    except Exception as e:
-        if not silent_errors:
-            msg = f"Error loading file {file_path}: {e}"
-            raise ValueError(msg) from e
-        return None
-
-    # Create a Data
-    text = "\n\n".join([str(el) for el in elements])
-    metadata = elements.metadata if hasattr(elements, "metadata") else {}
-    metadata["file_path"] = file_path
-    return Data(text=text, data=metadata)
-
-
-def read_text_file(file_path: str) -> str:
-    file_path_ = Path(file_path)
-    raw_data = file_path_.read_bytes()
-    result = chardet.detect(raw_data)
-    encoding = result["encoding"]
-
-    if encoding in {"Windows-1252", "Windows-1254", "MacRoman"}:
-        encoding = "utf-8"
-
-    return file_path_.read_text(encoding=encoding)
-
-
-def read_docx_file(file_path: str) -> str:
-    from docx import Document
-
-    doc = Document(file_path)
-    return "\n\n".join([p.text for p in doc.paragraphs])
-
-
-def parse_pdf_to_text(file_path: str) -> str:
-    from pypdf import PdfReader
-
-    with Path(file_path).open("rb") as f, PdfReader(f) as reader:
-        return "\n\n".join([page.extract_text() for page in reader.pages])
-
-
-def parse_text_file_to_data(file_path: str, *, silent_errors: bool) -> Data | None:
-    try:
-        if file_path.endswith(".pdf"):
-            text = parse_pdf_to_text(file_path)
-        elif file_path.endswith(".docx"):
-            text = read_docx_file(file_path)
-        else:
-            text = read_text_file(file_path)
-
-        # if file is json, yaml, or xml, we can parse it
-        if file_path.endswith(".json"):
-            loaded_json = orjson.loads(text)
-            if isinstance(loaded_json, dict):
-                loaded_json = {k: normalize_text(v) if isinstance(v, str) else v for k, v in loaded_json.items()}
-            elif isinstance(loaded_json, list):
-                loaded_json = [normalize_text(item) if isinstance(item, str) else item for item in loaded_json]
-            text = orjson.dumps(loaded_json).decode("utf-8")
-
-        elif file_path.endswith((".yaml", ".yml")):
-            text = yaml.safe_load(text)
-        elif file_path.endswith(".xml"):
-            xml_element = ElementTree.fromstring(text)
-            text = ElementTree.tostring(xml_element, encoding="unicode")
-    except Exception as e:
-        if not silent_errors:
-            msg = f"Error loading file {file_path}: {e}"
-            raise ValueError(msg) from e
-        return None
-
-    return Data(data={"file_path": file_path, "text": text})
-
-
-# ! Removing unstructured dependency until
-# ! 3.12 is supported
-# def get_elements(
-#     file_paths: List[str],
-#     silent_errors: bool,
-#     max_concurrency: int,
-#     use_multithreading: bool,
-# ) -> List[Optional[Data]]:
-#     if use_multithreading:
-#         data = parallel_load_data(file_paths, silent_errors, max_concurrency)
-#     else:
-#         data = [partition_file_to_data(file_path, silent_errors) for file_path in file_paths]
-#     data = list(filter(None, data))
-#     return data
-
-
-def parallel_load_data(
-    file_paths: list[str],
-    *,
-    silent_errors: bool,
-    max_concurrency: int,
-    load_function: Callable = parse_text_file_to_data,
-) -> list[Data | None]:
-    with futures.ThreadPoolExecutor(max_workers=max_concurrency) as executor:
-        loaded_files = executor.map(
-            lambda file_path: load_function(file_path, silent_errors=silent_errors),
-            file_paths,
-        )
-    # loaded_files is an iterator, so we need to convert it to a list
-    return list(loaded_files)
+from lfx.base.data.utils import *  # noqa: F403

langflow/base/embeddings/__init__.py

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

langflow/base/io/__init__.py

@@ -0,0 +1,7 @@
+"""Backwards compatibility module for langflow.base.io.
+
+This module imports from lfx.base.io to maintain compatibility.
+"""
+
+# Import all io modules from lfx for backwards compatibility
+from lfx.base.io import *  # noqa: F403

langflow/base/io/chat.py

@@ -1,20 +1,7 @@
-from langflow.custom.custom_component.component import Component
+"""Backwards compatibility module for langflow.base.io.chat.
 
+This module imports from lfx.base.io.chat to maintain compatibility.
+"""
 
-class ChatComponent(Component):
-    display_name = "Chat Component"
-    description = "Use as base for chat components."
-
-    def get_properties_from_source_component(self):
-        if hasattr(self, "_vertex") and hasattr(self._vertex, "incoming_edges") and self._vertex.incoming_edges:
-            source_id = self._vertex.incoming_edges[0].source_id
-            source_vertex = self.graph.get_vertex(source_id)
-            component = source_vertex.custom_component
-            source = component.display_name
-            icon = component.icon
-            possible_attributes = ["model_name", "model_id", "model"]
-            for attribute in possible_attributes:
-                if hasattr(component, attribute) and getattr(component, attribute):
-                    return getattr(component, attribute), icon, source, component._id
-            return source, icon, component.display_name, component._id
-        return None, None, None, None
+# Import all chat modules from lfx for backwards compatibility
+from lfx.base.io.chat import *  # noqa: F403

langflow/base/io/text.py

@@ -1,22 +1,3 @@
-from langflow.custom.custom_component.component import Component
+"""Backwards compatibility module for langflow.base.io.text."""
 
-
-class TextComponent(Component):
-    display_name = "Text Component"
-    description = "Used to pass text to the next component."
-
-    def build_config(self):
-        return {
-            "input_value": {
-                "display_name": "Value",
-                "input_types": ["Message", "Data"],
-                "info": "Text or Data to be passed.",
-            },
-            "data_template": {
-                "display_name": "Data Template",
-                "multiline": True,
-                "info": "Template to convert Data to Text. "
-                "If left empty, it will be dynamically set to the Data's text key.",
-                "advanced": True,
-            },
-        }
+from lfx.base.io.text import *  # noqa: F403

langflow/base/knowledge_bases/__init__.py

@@ -0,0 +1,3 @@
+from .knowledge_base_utils import compute_bm25, compute_tfidf, get_knowledge_bases
+
+__all__ = ["compute_bm25", "compute_tfidf", "get_knowledge_bases"]

langflow/base/memory/__init__.py

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

langflow/base/models/__init__.py

@@ -1,3 +1,3 @@
-from .model import LCModelComponent
+"""Backwards compatibility module for langflow.base.models."""
 
-__all__ = ["LCModelComponent"]
+from lfx.base.models import *  # noqa: F403

langflow/base/models/openai_constants.py

@@ -1,121 +1,7 @@
-from .model_metadata import create_model_metadata
+# Forward import for OpenAI constants
+from lfx.base.models.openai_constants import (
+    OPENAI_EMBEDDING_MODEL_NAMES,
+    OPENAI_MODEL_NAMES,
+)
 
-# Unified model metadata - single source of truth
-OPENAI_MODELS_DETAILED = [
-    # GPT-5 Series
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-5",
-        icon="OpenAI",
-        tool_calling=True,
-        reasoning=True,
-    ),
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-5-mini",
-        icon="OpenAI",
-        tool_calling=True,
-        reasoning=True,
-    ),
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-5-nano",
-        icon="OpenAI",
-        tool_calling=True,
-        reasoning=True,
-    ),
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-5-chat-latest",
-        icon="OpenAI",
-        tool_calling=False,
-        reasoning=True,
-    ),
-    # Regular OpenAI Models
-    create_model_metadata(provider="OpenAI", name="gpt-4o-mini", icon="OpenAI", tool_calling=True),
-    create_model_metadata(provider="OpenAI", name="gpt-4o", icon="OpenAI", tool_calling=True),
-    create_model_metadata(provider="OpenAI", name="gpt-4.1", icon="OpenAI", tool_calling=True),
-    create_model_metadata(provider="OpenAI", name="gpt-4.1-mini", icon="OpenAI", tool_calling=True),
-    create_model_metadata(provider="OpenAI", name="gpt-4.1-nano", icon="OpenAI", tool_calling=True),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4.5-preview", icon="OpenAI", tool_calling=True, preview=True, not_supported=True
-    ),
-    create_model_metadata(provider="OpenAI", name="gpt-4-turbo", icon="OpenAI", tool_calling=True),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4-turbo-preview", icon="OpenAI", tool_calling=True, preview=True
-    ),
-    create_model_metadata(provider="OpenAI", name="gpt-4", icon="OpenAI", tool_calling=True),
-    create_model_metadata(provider="OpenAI", name="gpt-3.5-turbo", icon="OpenAI", tool_calling=True),
-    # Reasoning Models
-    create_model_metadata(provider="OpenAI", name="o1", icon="OpenAI", reasoning=True),
-    create_model_metadata(provider="OpenAI", name="o1-mini", icon="OpenAI", reasoning=True, not_supported=True),
-    create_model_metadata(provider="OpenAI", name="o1-pro", icon="OpenAI", reasoning=True, not_supported=True),
-    create_model_metadata(provider="OpenAI", name="o3-mini", icon="OpenAI", reasoning=True),
-    create_model_metadata(provider="OpenAI", name="o3", icon="OpenAI", reasoning=True),
-    create_model_metadata(provider="OpenAI", name="o3-pro", icon="OpenAI", reasoning=True),
-    create_model_metadata(provider="OpenAI", name="o4-mini", icon="OpenAI", reasoning=True),
-    create_model_metadata(provider="OpenAI", name="o4-mini-high", icon="OpenAI", reasoning=True),
-    # Search Models
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-4o-mini-search-preview",
-        icon="OpenAI",
-        tool_calling=True,
-        search=True,
-        preview=True,
-    ),
-    create_model_metadata(
-        provider="OpenAI",
-        name="gpt-4o-search-preview",
-        icon="OpenAI",
-        tool_calling=True,
-        search=True,
-        preview=True,
-    ),
-    # Not Supported Models
-    create_model_metadata(
-        provider="OpenAI", name="computer-use-preview", icon="OpenAI", not_supported=True, preview=True
-    ),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4o-audio-preview", icon="OpenAI", not_supported=True, preview=True
-    ),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4o-realtime-preview", icon="OpenAI", not_supported=True, preview=True
-    ),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4o-mini-audio-preview", icon="OpenAI", not_supported=True, preview=True
-    ),
-    create_model_metadata(
-        provider="OpenAI", name="gpt-4o-mini-realtime-preview", icon="OpenAI", not_supported=True, preview=True
-    ),
-]
-OPENAI_CHAT_MODEL_NAMES = [
-    metadata["name"]
-    for metadata in OPENAI_MODELS_DETAILED
-    if not metadata.get("not_supported", False)
-    and not metadata.get("reasoning", False)
-    and not metadata.get("search", False)
-]
-
-OPENAI_REASONING_MODEL_NAMES = [
-    metadata["name"]
-    for metadata in OPENAI_MODELS_DETAILED
-    if metadata.get("reasoning", False) and not metadata.get("not_supported", False)
-]
-
-OPENAI_SEARCH_MODEL_NAMES = [
-    metadata["name"]
-    for metadata in OPENAI_MODELS_DETAILED
-    if metadata.get("search", False) and not metadata.get("not_supported", False)
-]
-
-NOT_SUPPORTED_MODELS = [metadata["name"] for metadata in OPENAI_MODELS_DETAILED if metadata.get("not_supported", False)]
-
-OPENAI_EMBEDDING_MODEL_NAMES = [
-    "text-embedding-3-small",
-    "text-embedding-3-large",
-    "text-embedding-ada-002",
-]
-
-# Backwards compatibility
-MODEL_NAMES = OPENAI_CHAT_MODEL_NAMES
+__all__ = ["OPENAI_EMBEDDING_MODEL_NAMES", "OPENAI_MODEL_NAMES"]

langflow/base/prompts/__init__.py

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

langflow/base/prompts/api_utils.py

@@ -1,224 +1,3 @@
-from collections import defaultdict
-from typing import Any
+"""Backwards compatibility module for langflow.base.prompts.api_utils."""
 
-from fastapi import HTTPException
-from langchain_core.prompts import PromptTemplate
-
-from langflow.inputs.inputs import DefaultPromptField
-from langflow.interface.utils import extract_input_variables_from_prompt
-from langflow.logging.logger import logger
-
-_INVALID_CHARACTERS = {
-    " ",
-    ",",
-    ".",
-    ":",
-    ";",
-    "!",
-    "?",
-    "/",
-    "\\",
-    "(",
-    ")",
-    "[",
-    "]",
-}
-
-_INVALID_NAMES = {
-    "code",
-    "input_variables",
-    "output_parser",
-    "partial_variables",
-    "template",
-    "template_format",
-    "validate_template",
-}
-
-
-def _is_json_like(var):
-    if var.startswith("{{") and var.endswith("}}"):
-        # If it is a double brance variable
-        # we don't want to validate any of its content
-        return True
-    # the above doesn't work on all cases because the json string can be multiline
-    # or indented which can add \n or spaces at the start or end of the string
-    # test_case_3 new_var == '\n{{\n    "test": "hello",\n    "text": "world"\n}}\n'
-    # what we can do is to remove the \n and spaces from the start and end of the string
-    # and then check if the string starts with {{ and ends with }}
-    var = var.strip()
-    var = var.replace("\n", "")
-    var = var.replace(" ", "")
-    # Now it should be a valid json string
-    return var.startswith("{{") and var.endswith("}}")
-
-
-def _fix_variable(var, invalid_chars, wrong_variables):
-    if not var:
-        return var, invalid_chars, wrong_variables
-    new_var = var
-
-    # Handle variables starting with a number
-    if var[0].isdigit():
-        invalid_chars.append(var[0])
-        new_var, invalid_chars, wrong_variables = _fix_variable(var[1:], invalid_chars, wrong_variables)
-
-    # Temporarily replace {{ and }} to avoid treating them as invalid
-    new_var = new_var.replace("{{", "ᴛᴇᴍᴘᴏᴘᴇɴ").replace("}}", "ᴛᴇᴍᴘᴄʟᴏsᴇ")  # noqa: RUF001
-
-    # Remove invalid characters
-    for char in new_var:
-        if char in _INVALID_CHARACTERS:
-            invalid_chars.append(char)
-            new_var = new_var.replace(char, "")
-            if var not in wrong_variables:  # Avoid duplicating entries
-                wrong_variables.append(var)
-
-    # Restore {{ and }}
-    new_var = new_var.replace("ᴛᴇᴍᴘᴏᴘᴇɴ", "{{").replace("ᴛᴇᴍᴘᴄʟᴏsᴇ", "}}")  # noqa: RUF001
-
-    return new_var, invalid_chars, wrong_variables
-
-
-def _check_variable(var, invalid_chars, wrong_variables, empty_variables):
-    if any(char in invalid_chars for char in var):
-        wrong_variables.append(var)
-    elif var == "":
-        empty_variables.append(var)
-    return wrong_variables, empty_variables
-
-
-def _check_for_errors(input_variables, fixed_variables, wrong_variables, empty_variables) -> None:
-    if any(var for var in input_variables if var not in fixed_variables):
-        error_message = (
-            f"Error: Input variables contain invalid characters or formats. \n"
-            f"Invalid variables: {', '.join(wrong_variables)}.\n"
-            f"Empty variables: {', '.join(empty_variables)}. \n"
-            f"Fixed variables: {', '.join(fixed_variables)}."
-        )
-        raise ValueError(error_message)
-
-
-def _check_input_variables(input_variables):
-    invalid_chars = []
-    fixed_variables = []
-    wrong_variables = []
-    empty_variables = []
-    variables_to_check = []
-
-    for var in input_variables:
-        # First, let's check if the variable is a JSON string
-        # because if it is, it won't be considered a variable
-        # and we don't need to validate it
-        if _is_json_like(var):
-            continue
-
-        new_var, wrong_variables, empty_variables = _fix_variable(var, invalid_chars, wrong_variables)
-        wrong_variables, empty_variables = _check_variable(var, _INVALID_CHARACTERS, wrong_variables, empty_variables)
-        fixed_variables.append(new_var)
-        variables_to_check.append(var)
-
-    _check_for_errors(variables_to_check, fixed_variables, wrong_variables, empty_variables)
-
-    return fixed_variables
-
-
-def validate_prompt(prompt_template: str, *, silent_errors: bool = False) -> list[str]:
-    input_variables = extract_input_variables_from_prompt(prompt_template)
-
-    # Check if there are invalid characters in the input_variables
-    input_variables = _check_input_variables(input_variables)
-    if any(var in _INVALID_NAMES for var in input_variables):
-        msg = f"Invalid input variables. None of the variables can be named {', '.join(input_variables)}. "
-        raise ValueError(msg)
-
-    try:
-        PromptTemplate(template=prompt_template, input_variables=input_variables)
-    except Exception as exc:
-        msg = f"Invalid prompt: {exc}"
-        logger.exception(msg)
-        if not silent_errors:
-            raise ValueError(msg) from exc
-
-    return input_variables
-
-
-def get_old_custom_fields(custom_fields, name):
-    try:
-        if len(custom_fields) == 1 and name == "":
-            # If there is only one custom field and the name is empty string
-            # then we are dealing with the first prompt request after the node was created
-            name = next(iter(custom_fields.keys()))
-
-        old_custom_fields = custom_fields[name]
-        if not old_custom_fields:
-            old_custom_fields = []
-
-        old_custom_fields = old_custom_fields.copy()
-    except KeyError:
-        old_custom_fields = []
-    custom_fields[name] = []
-    return old_custom_fields
-
-
-def add_new_variables_to_template(input_variables, custom_fields, template, name) -> None:
-    for variable in input_variables:
-        try:
-            template_field = DefaultPromptField(name=variable, display_name=variable)
-            if variable in template:
-                # Set the new field with the old value
-                template_field.value = template[variable]["value"]
-
-            template[variable] = template_field.to_dict()
-
-            # Check if variable is not already in the list before appending
-            if variable not in custom_fields[name]:
-                custom_fields[name].append(variable)
-
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-
-def remove_old_variables_from_template(old_custom_fields, input_variables, custom_fields, template, name) -> None:
-    for variable in old_custom_fields:
-        if variable not in input_variables:
-            try:
-                # Remove the variable from custom_fields associated with the given name
-                if variable in custom_fields[name]:
-                    custom_fields[name].remove(variable)
-
-                # Remove the variable from the template
-                template.pop(variable, None)
-
-            except Exception as exc:
-                raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-
-def update_input_variables_field(input_variables, template) -> None:
-    if "input_variables" in template:
-        template["input_variables"]["value"] = input_variables
-
-
-def process_prompt_template(
-    template: str, name: str, custom_fields: dict[str, list[str]] | None, frontend_node_template: dict[str, Any]
-):
-    """Process and validate prompt template, update template and custom fields."""
-    # Validate the prompt template and extract input variables
-    input_variables = validate_prompt(template)
-
-    # Initialize custom_fields if None
-    if custom_fields is None:
-        custom_fields = defaultdict(list)
-
-    # Retrieve old custom fields
-    old_custom_fields = get_old_custom_fields(custom_fields, name)
-
-    # Add new variables to the template
-    add_new_variables_to_template(input_variables, custom_fields, frontend_node_template, name)
-
-    # Remove old variables from the template
-    remove_old_variables_from_template(old_custom_fields, input_variables, custom_fields, frontend_node_template, name)
-
-    # Update the input variables field in the template
-    update_input_variables_field(input_variables, frontend_node_template)
-
-    return input_variables
+from lfx.base.prompts.api_utils import *  # noqa: F403

langflow/base/textsplitters/__init__.py

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

langflow/base/tools/__init__.py

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

langflow/base/vectorstores/__init__.py

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