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

langflow/interface/utils.py

@@ -1,112 +1,4 @@
-import base64
-import json
-import os
-from io import BytesIO
-from pathlib import Path
-from string import Formatter
+"""Interface utils module for langflow - imports from lfx."""
 
-import yaml
-from langchain_core.language_models import BaseLanguageModel
-from PIL.Image import Image
-
-from langflow.logging.logger import logger
-from langflow.services.chat.config import ChatConfig
-from langflow.services.deps import get_settings_service
-
-
-def load_file_into_dict(file_path: str) -> dict:
-    file_path_ = Path(file_path)
-    if not file_path_.exists():
-        msg = f"File not found: {file_path}"
-        raise FileNotFoundError(msg)
-
-    # Files names are UUID, so we can't find the extension
-    with file_path_.open(encoding="utf-8") as file:
-        try:
-            data = json.load(file)
-        except json.JSONDecodeError:
-            file.seek(0)
-            data = yaml.safe_load(file)
-        except ValueError as exc:
-            msg = "Invalid file type. Expected .json or .yaml."
-            raise ValueError(msg) from exc
-    return data
-
-
-def pil_to_base64(image: Image) -> str:
-    buffered = BytesIO()
-    image.save(buffered, format="PNG")
-    img_str = base64.b64encode(buffered.getvalue())
-    return img_str.decode("utf-8")
-
-
-def try_setting_streaming_options(langchain_object):
-    # If the LLM type is OpenAI or ChatOpenAI,
-    # set streaming to True
-    # First we need to find the LLM
-    llm = None
-    if hasattr(langchain_object, "llm"):
-        llm = langchain_object.llm
-    elif hasattr(langchain_object, "llm_chain") and hasattr(langchain_object.llm_chain, "llm"):
-        llm = langchain_object.llm_chain.llm
-
-    if isinstance(llm, BaseLanguageModel):
-        if hasattr(llm, "streaming") and isinstance(llm.streaming, bool):
-            llm.streaming = ChatConfig.streaming
-        elif hasattr(llm, "stream") and isinstance(llm.stream, bool):
-            llm.stream = ChatConfig.streaming
-
-    return langchain_object
-
-
-def extract_input_variables_from_prompt(prompt: str) -> list[str]:
-    """Extract variable names from a prompt string using Python's built-in string formatter.
-
-    Uses the same convention as Python's .format() method:
-    - Single braces {name} are variable placeholders
-    - Double braces {{name}} are escape sequences that render as literal {name}
-    """
-    formatter = Formatter()
-    variables: list[str] = []
-    seen: set[str] = set()
-
-    # Use local bindings for micro-optimization
-    variables_append = variables.append
-    seen_add = seen.add
-    seen_contains = seen.__contains__
-
-    for _, field_name, _, _ in formatter.parse(prompt):
-        if field_name and not seen_contains(field_name):
-            variables_append(field_name)
-            seen_add(field_name)
-
-    return variables
-
-
-def setup_llm_caching() -> None:
-    """Setup LLM caching."""
-    settings_service = get_settings_service()
-    try:
-        set_langchain_cache(settings_service.settings)
-    except ImportError:
-        logger.warning(f"Could not import {settings_service.settings.cache_type}. ")
-    except Exception:  # noqa: BLE001
-        logger.warning("Could not setup LLM caching.")
-
-
-def set_langchain_cache(settings) -> None:
-    from langchain.globals import set_llm_cache
-
-    from langflow.interface.importing.utils import import_class
-
-    if cache_type := os.getenv("LANGFLOW_LANGCHAIN_CACHE"):
-        try:
-            cache_class = import_class(f"langchain_community.cache.{cache_type or settings.LANGCHAIN_CACHE}")
-
-            logger.debug(f"Setting up LLM caching with {cache_class.__name__}")
-            set_llm_cache(cache_class())
-            logger.info(f"LLM caching setup with {cache_class.__name__}")
-        except ImportError:
-            logger.warning(f"Could not import {cache_type}. ")
-    else:
-        logger.debug("No LLM cache set.")
+# Import everything from lfx.interface.utils
+from lfx.interface.utils import *  # noqa: F403

langflow/io/__init__.py

@@ -1,4 +1,4 @@
-from langflow.inputs import (
+from lfx.io import (
     BoolInput,
     CodeInput,
     DataFrameInput,
@@ -27,7 +27,7 @@ from langflow.inputs import (
     TableInput,
     ToolsInput,
 )
-from langflow.template import Output
+from lfx.template import Output
 
 __all__ = [
     "BoolInput",

langflow/io/schema.py

@@ -1,304 +1,13 @@
-from types import UnionType
-from typing import Any, Literal, Union, get_args, get_origin
-
-from pydantic import BaseModel, Field, create_model
-
-from langflow.inputs.inputs import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FieldTypes,
-    FloatInput,
-    InputTypes,
-    IntInput,
-    MessageTextInput,
+from lfx.io.schema import (
+    create_input_schema,
+    create_input_schema_from_dict,
+    flatten_schema,
+    schema_to_langflow_inputs,
 )
-from langflow.schema.dotdict import dotdict
-
-_convert_field_type_to_type: dict[FieldTypes, type] = {
-    FieldTypes.TEXT: str,
-    FieldTypes.INTEGER: int,
-    FieldTypes.FLOAT: float,
-    FieldTypes.BOOLEAN: bool,
-    FieldTypes.DICT: dict,
-    FieldTypes.NESTED_DICT: dict,
-    FieldTypes.TABLE: dict,
-    FieldTypes.FILE: str,
-    FieldTypes.PROMPT: str,
-    FieldTypes.CODE: str,
-    FieldTypes.OTHER: str,
-    FieldTypes.TAB: str,
-    FieldTypes.QUERY: str,
-}
-
-
-_convert_type_to_field_type = {
-    str: MessageTextInput,
-    int: IntInput,
-    float: FloatInput,
-    bool: BoolInput,
-    dict: DictInput,
-    list: MessageTextInput,
-}
-
-
-def flatten_schema(root_schema: dict[str, Any]) -> dict[str, Any]:
-    """Flatten a JSON RPC style schema into a single level JSON Schema.
-
-    If the input schema is already flat (no $defs / $ref / nested objects or arrays)
-    the function simply returns the original i.e. a noop.
-    """
-    defs = root_schema.get("$defs", {})
-
-    # --- Fast path: schema is already flat ---------------------------------
-    props = root_schema.get("properties", {})
-    if not defs and all("$ref" not in v and v.get("type") not in ("object", "array") for v in props.values()):
-        return root_schema
-    # -----------------------------------------------------------------------
-
-    flat_props: dict[str, dict[str, Any]] = {}
-    required_list: list[str] = []
-
-    def _resolve_if_ref(schema: dict[str, Any]) -> dict[str, Any]:
-        while "$ref" in schema:
-            ref_name = schema["$ref"].split("/")[-1]
-            schema = defs.get(ref_name, {})
-        return schema
-
-    def _walk(name: str, schema: dict[str, Any], *, inherited_req: bool) -> None:
-        schema = _resolve_if_ref(schema)
-        t = schema.get("type")
-
-        # ── objects ─────────────────────────────────────────────────────────
-        if t == "object":
-            req_here = set(schema.get("required", []))
-            for k, subschema in schema.get("properties", {}).items():
-                child_name = f"{name}.{k}" if name else k
-                _walk(name=child_name, schema=subschema, inherited_req=inherited_req and k in req_here)
-            return
-
-        # ── arrays (always recurse into the first item as “[0]”) ───────────
-        if t == "array":
-            items = schema.get("items", {})
-            _walk(name=f"{name}[0]", schema=items, inherited_req=inherited_req)
-            return
-
-        leaf: dict[str, Any] = {
-            k: v
-            for k, v in schema.items()
-            if k
-            in (
-                "type",
-                "description",
-                "pattern",
-                "format",
-                "enum",
-                "default",
-                "minLength",
-                "maxLength",
-                "minimum",
-                "maximum",
-                "exclusiveMinimum",
-                "exclusiveMaximum",
-                "additionalProperties",
-                "examples",
-            )
-        }
-        flat_props[name] = leaf
-        if inherited_req:
-            required_list.append(name)
-
-    # kick things off at the true root
-    root_required = set(root_schema.get("required", []))
-    for k, subschema in props.items():
-        _walk(k, subschema, inherited_req=k in root_required)
-
-    # build the flattened schema; keep any descriptive metadata
-    result: dict[str, Any] = {
-        "type": "object",
-        "properties": flat_props,
-        **{k: v for k, v in root_schema.items() if k not in ("properties", "$defs")},
-    }
-    if required_list:
-        result["required"] = required_list
-    return result
-
-
-def schema_to_langflow_inputs(schema: type[BaseModel]) -> list[InputTypes]:
-    inputs: list[InputTypes] = []
-
-    for field_name, model_field in schema.model_fields.items():
-        ann = model_field.annotation
-        if isinstance(ann, UnionType):
-            # Extract non-None types from Union
-            non_none_types = [t for t in get_args(ann) if t is not type(None)]
-            if len(non_none_types) == 1:
-                ann = non_none_types[0]
-
-        is_list = False
-
-        if get_origin(ann) is list:
-            is_list = True
-            ann = get_args(ann)[0]
-
-        options: list[Any] | None = None
-        if get_origin(ann) is Literal:
-            options = list(get_args(ann))
-            if options:
-                ann = type(options[0])
-
-        if get_origin(ann) is Union:
-            non_none = [t for t in get_args(ann) if t is not type(None)]
-            if len(non_none) == 1:
-                ann = non_none[0]
-
-        # 1) Nested Pydantic model?
-        # if isinstance(ann, type) and issubclass(ann, BaseModel):
-        #    nested = schema_to_langflow_inputs(ann)
-        #    inputs.append(
-        #        ObjectInput(
-        #            display_name=model_field.title or field_name.replace("_", " ").title(),
-        #            name=field_name,
-        #            info=model_field.description or "",
-        #            required=model_field.is_required(),
-        #            is_list=is_list,
-        #            inputs=nested,
-        #        )
-        #    )
-        #    continue
-
-        # 2) Enumerated choices
-        if options is not None:
-            inputs.append(
-                DropdownInput(
-                    display_name=model_field.title or field_name.replace("_", " ").title(),
-                    name=field_name,
-                    info=model_field.description or "",
-                    required=model_field.is_required(),
-                    is_list=is_list,
-                    options=options,
-                )
-            )
-            continue
-
-        # 3) “Any” fallback → text
-        if ann is Any:
-            inputs.append(
-                MessageTextInput(
-                    display_name=model_field.title or field_name.replace("_", " ").title(),
-                    name=field_name,
-                    info=model_field.description or "",
-                    required=model_field.is_required(),
-                    is_list=is_list,
-                )
-            )
-            continue
-
-        # 4) Primitive via your mapping
-        try:
-            lf_cls = _convert_type_to_field_type[ann]
-        except KeyError as err:
-            msg = f"Unsupported field type: {ann}"
-            raise TypeError(msg) from err
-        inputs.append(
-            lf_cls(
-                display_name=model_field.title or field_name.replace("_", " ").title(),
-                name=field_name,
-                info=model_field.description or "",
-                required=model_field.is_required(),
-                is_list=is_list,
-            )
-        )
-
-    return inputs
-
-
-def create_input_schema(inputs: list["InputTypes"]) -> type[BaseModel]:
-    if not isinstance(inputs, list):
-        msg = "inputs must be a list of Inputs"
-        raise TypeError(msg)
-    fields = {}
-    for input_model in inputs:
-        # Create a Pydantic Field for each input field
-        field_type = input_model.field_type
-        if isinstance(field_type, FieldTypes):
-            field_type = _convert_field_type_to_type[field_type]
-        else:
-            msg = f"Invalid field type: {field_type}"
-            raise TypeError(msg)
-        if hasattr(input_model, "options") and isinstance(input_model.options, list) and input_model.options:
-            literal_string = f"Literal{input_model.options}"
-            # validate that the literal_string is a valid literal
-
-            field_type = eval(literal_string, {"Literal": Literal})  # noqa: S307
-        if hasattr(input_model, "is_list") and input_model.is_list:
-            field_type = list[field_type]  # type: ignore[valid-type]
-        if input_model.name:
-            name = input_model.name.replace("_", " ").title()
-        elif input_model.display_name:
-            name = input_model.display_name
-        else:
-            msg = "Input name or display_name is required"
-            raise ValueError(msg)
-        field_dict = {
-            "title": name,
-            "description": input_model.info or "",
-        }
-        if input_model.required is False:
-            field_dict["default"] = input_model.value  # type: ignore[assignment]
-        pydantic_field = Field(**field_dict)
-
-        fields[input_model.name] = (field_type, pydantic_field)
-
-    # Create and return the InputSchema model
-    model = create_model("InputSchema", **fields)
-    model.model_rebuild()
-    return model
-
-
-def create_input_schema_from_dict(inputs: list[dotdict], param_key: str | None = None) -> type[BaseModel]:
-    if not isinstance(inputs, list):
-        msg = "inputs must be a list of Inputs"
-        raise TypeError(msg)
-    fields = {}
-    for input_model in inputs:
-        # Create a Pydantic Field for each input field
-        field_type = input_model.type
-        if hasattr(input_model, "options") and isinstance(input_model.options, list) and input_model.options:
-            literal_string = f"Literal{input_model.options}"
-            # validate that the literal_string is a valid literal
-
-            field_type = eval(literal_string, {"Literal": Literal})  # noqa: S307
-        if hasattr(input_model, "is_list") and input_model.is_list:
-            field_type = list[field_type]  # type: ignore[valid-type]
-        if input_model.name:
-            name = input_model.name.replace("_", " ").title()
-        elif input_model.display_name:
-            name = input_model.display_name
-        else:
-            msg = "Input name or display_name is required"
-            raise ValueError(msg)
-        field_dict = {
-            "title": name,
-            "description": input_model.info or "",
-        }
-        if input_model.required is False:
-            field_dict["default"] = input_model.value  # type: ignore[assignment]
-        pydantic_field = Field(**field_dict)
-
-        fields[input_model.name] = (field_type, pydantic_field)
-
-    # Wrap fields in a dictionary with the key as param_key
-    if param_key is not None:
-        # Create an inner model with the fields
-        inner_model = create_model("InnerModel", **fields)
-
-        # Ensure the model is wrapped correctly in a dictionary
-        # model = create_model("InputSchema", **{param_key: (inner_model, Field(default=..., description=description))})
-        model = create_model("InputSchema", **{param_key: (inner_model, ...)})
-    else:
-        # Create and return the InputSchema model
-        model = create_model("InputSchema", **fields)
 
-    model.model_rebuild()
-    return model
+__all__ = [
+    "create_input_schema",
+    "create_input_schema_from_dict",
+    "flatten_schema",
+    "schema_to_langflow_inputs",
+]

langflow/load/__init__.py

@@ -1,5 +1,7 @@
-from .load import aload_flow_from_json, arun_flow_from_json, load_flow_from_json, run_flow_from_json
-from .utils import get_flow, replace_tweaks_with_env, upload_file
+from lfx.load.load import aload_flow_from_json, arun_flow_from_json, load_flow_from_json, run_flow_from_json
+from lfx.load.utils import replace_tweaks_with_env, upload_file
+
+from .utils import get_flow
 
 __all__ = [
     "aload_flow_from_json",

langflow/load/utils.py

@@ -1,80 +1,9 @@
-from pathlib import Path
-
 import httpx
+from lfx.load.utils import UploadError, replace_tweaks_with_env, upload, upload_file
 
 from langflow.services.database.models.flow.model import FlowBase
 
 
-class UploadError(Exception):
-    """Raised when an error occurs during the upload process."""
-
-
-def upload(file_path: str, host: str, flow_id: str):
-    """Upload a file to Langflow and return the file path.
-
-    Args:
-        file_path (str): The path to the file to be uploaded.
-        host (str): The host URL of Langflow.
-        flow_id (UUID): The ID of the flow to which the file belongs.
-
-    Returns:
-        dict: A dictionary containing the file path.
-
-    Raises:
-        UploadError: If an error occurs during the upload process.
-    """
-    try:
-        url = f"{host}/api/v1/upload/{flow_id}"
-        with Path(file_path).open("rb") as file:
-            response = httpx.post(url, files={"file": file})
-            if response.status_code in {httpx.codes.OK, httpx.codes.CREATED}:
-                return response.json()
-    except Exception as e:
-        msg = f"Error uploading file: {e}"
-        raise UploadError(msg) from e
-
-    msg = f"Error uploading file: {response.status_code}"
-    raise UploadError(msg)
-
-
-def upload_file(file_path: str, host: str, flow_id: str, components: list[str], tweaks: dict | None = None):
-    """Upload a file to Langflow and return the file path.
-
-    Args:
-        file_path (str): The path to the file to be uploaded.
-        host (str): The host URL of Langflow.
-        port (int): The port number of Langflow.
-        flow_id (UUID): The ID of the flow to which the file belongs.
-        components (str): List of component IDs or names that need the file.
-        tweaks (dict): A dictionary of tweaks to be applied to the file.
-
-    Returns:
-        dict: A dictionary containing the file path and any tweaks that were applied.
-
-    Raises:
-        UploadError: If an error occurs during the upload process.
-    """
-    try:
-        response = upload(file_path, host, flow_id)
-    except Exception as e:
-        msg = f"Error uploading file: {e}"
-        raise UploadError(msg) from e
-
-    if not tweaks:
-        tweaks = {}
-    if response["file_path"]:
-        for component in components:
-            if isinstance(component, str):
-                tweaks[component] = {"path": response["file_path"]}
-            else:
-                msg = f"Error uploading file: component ID or name must be a string. Got {type(component)}"
-                raise UploadError(msg)
-        return tweaks
-
-    msg = "Error uploading file"
-    raise UploadError(msg)
-
-
 def get_flow(url: str, flow_id: str):
     """Get the details of a flow from Langflow.
 
@@ -100,27 +29,4 @@ def get_flow(url: str, flow_id: str):
         raise UploadError(msg) from e
 
 
-def replace_tweaks_with_env(tweaks: dict, env_vars: dict) -> dict:
-    """Replace keys in the tweaks dictionary with their corresponding environment variable values.
-
-    This function recursively traverses the tweaks dictionary and replaces any string keys
-    with their values from the provided environment variables. If a key's value is a dictionary,
-    the function will call itself to handle nested dictionaries.
-
-    Args:
-        tweaks (dict): A dictionary containing keys that may correspond to environment variable names.
-        env_vars (dict): A dictionary of environment variables where keys are variable names
-                         and values are their corresponding values.
-
-    Returns:
-        dict: The updated tweaks dictionary with keys replaced by their environment variable values.
-    """
-    for key, value in tweaks.items():
-        if isinstance(value, dict):
-            # Recursively replace in nested dictionaries
-            tweaks[key] = replace_tweaks_with_env(value, env_vars)
-        elif isinstance(value, str):
-            env_value = env_vars.get(value)  # Get the value from the provided environment variables
-            if env_value is not None:
-                tweaks[key] = env_value
-    return tweaks
+__all__ = ["UploadError", "get_flow", "replace_tweaks_with_env", "upload", "upload_file"]

langflow/logging/__init__.py

@@ -1,4 +1,5 @@
-from .logger import configure, logger
+from lfx.log.logger import configure, logger
+
 from .setup import disable_logging, enable_logging
 
 __all__ = ["configure", "disable_logging", "enable_logging", "logger"]

langflow/logging/setup.py

@@ -1,4 +1,4 @@
-from langflow.logging.logger import logger
+from lfx.log.logger import logger
 
 LOGGING_CONFIGURED = False
 

langflow/main.py

@@ -17,6 +17,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi_pagination import add_pagination
+from lfx.interface.utils import setup_llm_caching
+from lfx.log.logger import configure, logger
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 from pydantic import PydanticDeprecatedSince20
 from pydantic_core import PydanticSerializationError
@@ -31,12 +33,9 @@ from langflow.initial_setup.setup import (
     load_flows_from_directory,
     sync_flows_from_fs,
 )
-from langflow.interface.components import get_and_cache_all_types_dict
-from langflow.interface.utils import setup_llm_caching
-from langflow.logging.logger import configure, logger
 from langflow.middleware import ContentSizeLimitMiddleware
 from langflow.services.deps import get_queue_service, get_settings_service, get_telemetry_service
-from langflow.services.utils import initialize_services, teardown_services
+from langflow.services.utils import initialize_services, initialize_settings_service, teardown_services
 
 if TYPE_CHECKING:
     from tempfile import TemporaryDirectory
@@ -115,9 +114,13 @@ async def load_bundles_with_error_handling():
 
 
 def get_lifespan(*, fix_migration=False, version=None):
+    initialize_settings_service()
+    telemetry_service = get_telemetry_service()
+
     @asynccontextmanager
     async def lifespan(_app: FastAPI):
-        telemetry_service = get_telemetry_service()
+        from lfx.interface.components import get_and_cache_all_types_dict
+
         configure()
 
         # Startup message

langflow/memory.py

@@ -5,15 +5,15 @@ from uuid import UUID
 
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.messages import BaseMessage
+from lfx.log.logger import logger
+from lfx.utils.async_helpers import run_until_complete
 from sqlalchemy import delete
 from sqlmodel import col, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from langflow.logging.logger import logger
 from langflow.schema.message import Message
 from langflow.services.database.models.message.model import MessageRead, MessageTable
 from langflow.services.deps import session_scope
-from langflow.utils.async_helpers import run_until_complete
 
 
 def _get_variable_query(
@@ -112,10 +112,16 @@ async def aadd_messages(messages: Message | list[Message], flow_id: str | UUID |
     if not isinstance(messages, list):
         messages = [messages]
 
-    if not all(isinstance(message, Message) for message in messages):
-        types = ", ".join([str(type(message)) for message in messages])
-        msg = f"The messages must be instances of Message. Found: {types}"
-        raise ValueError(msg)
+    # Check if all messages are Message instances (either from langflow or lfx)
+    for message in messages:
+        # Accept Message instances from both langflow and lfx packages
+        is_valid_message = isinstance(message, Message) or (
+            hasattr(message, "__class__") and message.__class__.__name__ in ["Message", "ErrorMessage"]
+        )
+        if not is_valid_message:
+            types = ", ".join([str(type(msg)) for msg in messages])
+            msg = f"The messages must be instances of Message. Found: {types}"
+            raise ValueError(msg)
 
     try:
         messages_models = [MessageTable.from_message(msg, flow_id=flow_id) for msg in messages]

langflow/middleware.py

@@ -1,6 +1,6 @@
 from fastapi import HTTPException
+from lfx.log.logger import logger
 
-from langflow.logging.logger import logger
 from langflow.services.deps import get_settings_service