lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/io/schema.py

@@ -0,0 +1,289 @@
+from types import UnionType
+from typing import Any, Literal, Union, get_args, get_origin
+
+from pydantic import BaseModel, Field, create_model
+
+from lfx.inputs.input_mixin import FieldTypes
+from lfx.inputs.inputs import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    FloatInput,
+    InputTypes,
+    IntInput,
+    MessageTextInput,
+)
+from lfx.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]
+
+        # 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

lfx/load/__init__.py

@@ -0,0 +1,8 @@
+from .load import aload_flow_from_json, arun_flow_from_json, load_flow_from_json, run_flow_from_json
+
+__all__ = [
+    "aload_flow_from_json",
+    "arun_flow_from_json",
+    "load_flow_from_json",
+    "run_flow_from_json",
+]

lfx/load/load.py

@@ -0,0 +1,256 @@
+import json
+from io import StringIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from aiofile import async_open
+from dotenv import dotenv_values
+
+from lfx.graph.schema import RunOutputs
+
+if TYPE_CHECKING:
+    from lfx.graph.graph.base import Graph
+
+from lfx.load.utils import replace_tweaks_with_env
+from lfx.log.logger import configure
+from lfx.processing.process import process_tweaks, run_graph
+from lfx.utils.async_helpers import run_until_complete
+from lfx.utils.util import update_settings
+
+
+async def aload_flow_from_json(
+    flow: Path | str | dict,
+    *,
+    tweaks: dict | None = None,
+    log_level: str | None = None,
+    log_file: str | None = None,
+    log_rotation: str | None = None,
+    env_file: str | None = None,
+    cache: str | None = None,
+    disable_logs: bool | None = True,
+) -> "Graph":
+    """Load a flow graph from a JSON file or a JSON object.
+
+    Args:
+        flow (Union[Path, str, dict]): The flow to load. It can be a file path (str or Path object)
+            or a JSON object (dict).
+        tweaks (Optional[dict]): Optional tweaks to apply to the loaded flow graph.
+        log_level (Optional[str]): Optional log level to configure for the flow processing.
+        log_file (Optional[str]): Optional log file to configure for the flow processing.
+        log_rotation (Optional[str]): Optional log rotation(Time/Size) to configure for the flow processing.
+        env_file (Optional[str]): Optional .env file to override environment variables.
+        cache (Optional[str]): Optional cache path to update the flow settings.
+        disable_logs (Optional[bool], default=True): Optional flag to disable logs during flow processing.
+            If log_level or log_file are set, disable_logs is not used.
+
+    Returns:
+        Graph: The loaded flow graph as a Graph object.
+
+    Raises:
+        TypeError: If the input is neither a file path (str or Path object) nor a JSON object (dict).
+
+    """
+    # If input is a file path, load JSON from the file
+    log_file_path = Path(log_file) if log_file else None
+    configure(log_level=log_level, log_file=log_file_path, disable=disable_logs, log_rotation=log_rotation)
+
+    # override env variables with .env file
+    if env_file and tweaks is not None:
+        async with async_open(Path(env_file), encoding="utf-8") as f:
+            content = await f.read()
+            env_vars = dotenv_values(stream=StringIO(content))
+        tweaks = replace_tweaks_with_env(tweaks=tweaks, env_vars=env_vars)
+
+    # Update settings with cache and components path
+    await update_settings(cache=cache)
+
+    if isinstance(flow, str | Path):
+        async with async_open(Path(flow), encoding="utf-8") as f:
+            content = await f.read()
+            flow_graph = json.loads(content)
+    # If input is a dictionary, assume it's a JSON object
+    elif isinstance(flow, dict):
+        flow_graph = flow
+    else:
+        msg = "Input must be either a file path (str) or a JSON object (dict)"
+        raise TypeError(msg)
+
+    graph_data = flow_graph["data"]
+    if tweaks is not None:
+        graph_data = process_tweaks(graph_data, tweaks)
+
+    from lfx.graph.graph.base import Graph
+
+    return Graph.from_payload(graph_data)
+
+
+def load_flow_from_json(
+    flow: Path | str | dict,
+    *,
+    tweaks: dict | None = None,
+    log_level: str | None = None,
+    log_file: str | None = None,
+    log_rotation: str | None = None,
+    env_file: str | None = None,
+    cache: str | None = None,
+    disable_logs: bool | None = True,
+) -> "Graph":
+    """Load a flow graph from a JSON file or a JSON object.
+
+    Args:
+        flow (Union[Path, str, dict]): The flow to load. It can be a file path (str or Path object)
+            or a JSON object (dict).
+        tweaks (Optional[dict]): Optional tweaks to apply to the loaded flow graph.
+        log_level (Optional[str]): Optional log level to configure for the flow processing.
+        log_file (Optional[str]): Optional log file to configure for the flow processing.
+        log_rotation (Optional[str]): Optional log rotation(Time/Size) to configure for the flow processing.
+        env_file (Optional[str]): Optional .env file to override environment variables.
+        cache (Optional[str]): Optional cache path to update the flow settings.
+        disable_logs (Optional[bool], default=True): Optional flag to disable logs during flow processing.
+            If log_level or log_file are set, disable_logs is not used.
+
+    Returns:
+        Graph: The loaded flow graph as a Graph object.
+
+    Raises:
+        TypeError: If the input is neither a file path (str or Path object) nor a JSON object (dict).
+
+    """
+    return run_until_complete(
+        aload_flow_from_json(
+            flow,
+            tweaks=tweaks,
+            log_level=log_level,
+            log_file=log_file,
+            log_rotation=log_rotation,
+            env_file=env_file,
+            cache=cache,
+            disable_logs=disable_logs,
+        )
+    )
+
+
+async def arun_flow_from_json(
+    flow: Path | str | dict,
+    input_value: str,
+    *,
+    session_id: str | None = None,
+    tweaks: dict | None = None,
+    input_type: str = "chat",
+    output_type: str = "chat",
+    output_component: str | None = None,
+    log_level: str | None = None,
+    log_file: str | None = None,
+    log_rotation: str | None = None,
+    env_file: str | None = None,
+    cache: str | None = None,
+    disable_logs: bool | None = True,
+    fallback_to_env_vars: bool = False,
+) -> list[RunOutputs]:
+    """Run a flow from a JSON file or dictionary.
+
+    Args:
+        flow (Union[Path, str, dict]): The path to the JSON file or the JSON dictionary representing the flow.
+        input_value (str): The input value to be processed by the flow.
+        session_id (str | None, optional): The session ID to be used for the flow. Defaults to None.
+        tweaks (Optional[dict], optional): Optional tweaks to be applied to the flow. Defaults to None.
+        input_type (str, optional): The type of the input value. Defaults to "chat".
+        output_type (str, optional): The type of the output value. Defaults to "chat".
+        output_component (Optional[str], optional): The specific component to output. Defaults to None.
+        log_level (Optional[str], optional): The log level to use. Defaults to None.
+        log_file (Optional[str], optional): The log file to write logs to. Defaults to None.
+        log_rotation (Optional[str], optional): The log rotation to use. Defaults to None.
+        env_file (Optional[str], optional): The environment file to load. Defaults to None.
+        cache (Optional[str], optional): The cache directory to use. Defaults to None.
+        disable_logs (Optional[bool], optional): Whether to disable logs. Defaults to True.
+        fallback_to_env_vars (bool, optional): Whether Global Variables should fallback to environment variables if
+            not found. Defaults to False.
+
+    Returns:
+        List[RunOutputs]: A list of RunOutputs objects representing the results of running the flow.
+    """
+    if tweaks is None:
+        tweaks = {}
+    tweaks["stream"] = False
+    graph = await aload_flow_from_json(
+        flow=flow,
+        tweaks=tweaks,
+        log_level=log_level,
+        log_file=log_file,
+        log_rotation=log_rotation,
+        env_file=env_file,
+        cache=cache,
+        disable_logs=disable_logs,
+    )
+    return await run_graph(
+        graph=graph,
+        session_id=session_id,
+        input_value=input_value,
+        input_type=input_type,
+        output_type=output_type,
+        output_component=output_component,
+        fallback_to_env_vars=fallback_to_env_vars,
+    )
+
+
+def run_flow_from_json(
+    flow: Path | str | dict,
+    input_value: str,
+    *,
+    session_id: str | None = None,
+    tweaks: dict | None = None,
+    input_type: str = "chat",
+    output_type: str = "chat",
+    output_component: str | None = None,
+    log_level: str | None = None,
+    log_file: str | None = None,
+    log_rotation: str | None = None,
+    env_file: str | None = None,
+    cache: str | None = None,
+    disable_logs: bool | None = True,
+    fallback_to_env_vars: bool = False,
+) -> list[RunOutputs]:
+    """Run a flow from a JSON file or dictionary.
+
+    Note:
+        This function is a synchronous wrapper around `arun_flow_from_json`.
+        It creates an event loop if one does not exist and runs the flow.
+
+    Args:
+        flow (Union[Path, str, dict]): The path to the JSON file or the JSON dictionary representing the flow.
+        input_value (str): The input value to be processed by the flow.
+        session_id (str | None, optional): The session ID to be used for the flow. Defaults to None.
+        tweaks (Optional[dict], optional): Optional tweaks to be applied to the flow. Defaults to None.
+        input_type (str, optional): The type of the input value. Defaults to "chat".
+        output_type (str, optional): The type of the output value. Defaults to "chat".
+        output_component (Optional[str], optional): The specific component to output. Defaults to None.
+        log_level (Optional[str], optional): The log level to use. Defaults to None.
+        log_file (Optional[str], optional): The log file to write logs to. Defaults to None.
+        log_rotation (Optional[str], optional): The log rotation to use. Defaults to None.
+        env_file (Optional[str], optional): The environment file to load. Defaults to None.
+        cache (Optional[str], optional): The cache directory to use. Defaults to None.
+        disable_logs (Optional[bool], optional): Whether to disable logs. Defaults to True.
+        fallback_to_env_vars (bool, optional): Whether Global Variables should fallback to environment variables if
+            not found. Defaults to False.
+
+    Returns:
+        List[RunOutputs]: A list of RunOutputs objects representing the results of running the flow.
+    """
+    return run_until_complete(
+        arun_flow_from_json(
+            flow,
+            input_value,
+            session_id=session_id,
+            tweaks=tweaks,
+            input_type=input_type,
+            output_type=output_type,
+            output_component=output_component,
+            log_level=log_level,
+            log_file=log_file,
+            log_rotation=log_rotation,
+            env_file=env_file,
+            cache=cache,
+            disable_logs=disable_logs,
+            fallback_to_env_vars=fallback_to_env_vars,
+        )
+    )

lfx/load/utils.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+
+import httpx
+
+
+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 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

lfx/log/__init__.py

@@ -0,0 +1,5 @@
+"""Logging module for lfx package."""
+
+from lfx.log.logger import configure, logger
+
+__all__ = ["configure", "logger"]