lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/template/field/base.py

@@ -0,0 +1,260 @@
+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]
+)
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
+
+from lfx.field_typing import Text
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.helpers.custom import format_type
+from lfx.schema.data import Data
+from lfx.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."""
+
+    loop_types: list[str] | None = Field(default=None)
+    """List of additional types to include for loop inputs when allows_loop is True."""
+
+    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

lfx/template/field/prompt.py

@@ -0,0 +1,15 @@
+# This file provides backwards compatibility for prompt field constants
+from lfx.template.field.base import Input
+
+# Default input types for prompt fields
+DEFAULT_PROMPT_INTUT_TYPES = ["Message"]
+
+
+class DefaultPromptField(Input):
+    """Default prompt field for backwards compatibility."""
+
+    field_type: str = "str"
+    advanced: bool = False
+    multiline: bool = True
+    input_types: list[str] = DEFAULT_PROMPT_INTUT_TYPES
+    value: str = ""  # Set the value to empty string

lfx/template/frontend_node/__init__.py

@@ -0,0 +1,6 @@
+from lfx.template.frontend_node import base, custom_components
+
+__all__ = [
+    "base",
+    "custom_components",
+]

lfx/template/frontend_node/base.py

@@ -0,0 +1,214 @@
+from collections import defaultdict
+
+from pydantic import BaseModel, field_serializer, model_serializer
+
+from lfx.template.field.base import Output
+from lfx.template.template.base import Template
+
+
+class FrontendNode(BaseModel):
+    _format_template: bool = True
+    template: Template
+    """Template for the frontend node."""
+    description: str | None = None
+    """Description of the frontend node."""
+    icon: str | None = None
+    """Icon of the frontend node."""
+    is_input: bool | None = None
+    """Whether the frontend node is used as an input when processing the Graph.
+    If True, there should be a field named 'input_value'."""
+    is_output: bool | None = None
+    """Whether the frontend node is used as an output when processing the Graph.
+    If True, there should be a field named 'input_value'."""
+    is_composition: bool | None = None
+    """Whether the frontend node is used for composition."""
+    base_classes: list[str]
+    """List of base classes for the frontend node."""
+    name: str = ""
+    """Name of the frontend node."""
+    display_name: str | None = ""
+    """Display name of the frontend node."""
+    priority: int | None = None
+    """Priority of the frontend node."""
+    documentation: str = ""
+    """Documentation of the frontend node."""
+    minimized: bool = False
+    """Whether the frontend node is minimized."""
+    custom_fields: dict | None = defaultdict(list)
+    """Custom fields of the frontend node."""
+    output_types: list[str] = []
+    """List of output types for the frontend node."""
+    full_path: str | None = None
+    """Full path of the frontend node."""
+    pinned: bool = False
+    """Whether the frontend node is pinned."""
+    conditional_paths: list[str] = []
+    """List of conditional paths for the frontend node."""
+    frozen: bool = False
+    """Whether the frontend node is frozen."""
+    outputs: list[Output] = []
+    """List of output fields for the frontend node."""
+
+    field_order: list[str] = []
+    """Order of the fields in the frontend node."""
+    beta: bool = False
+    """Whether the frontend node is in beta."""
+    legacy: bool = False
+    """Whether the frontend node is legacy."""
+    replacement: list[str] | None = None
+    """Replacement for the frontend node when it is deprecated."""
+    error: str | None = None
+    """Error message for the frontend node."""
+    edited: bool = False
+    """Whether the frontend node has been edited."""
+    metadata: dict = {}
+    """Metadata for the component node."""
+    tool_mode: bool = False
+    """Whether the frontend node is in tool mode."""
+
+    def set_documentation(self, documentation: str) -> None:
+        """Sets the documentation of the frontend node."""
+        self.documentation = documentation
+
+    @field_serializer("base_classes")
+    def process_base_classes(self, base_classes: list[str]) -> list[str]:
+        """Removes unwanted base classes from the list of base classes."""
+        return sorted(set(base_classes), key=lambda x: x.lower())
+
+    @field_serializer("display_name")
+    def process_display_name(self, display_name: str) -> str:
+        """Sets the display name of the frontend node."""
+        return display_name or self.name
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        result = handler(self)
+        if hasattr(self, "template") and hasattr(self.template, "to_dict"):
+            result["template"] = self.template.to_dict()
+        name = result.pop("name")
+
+        # Migrate base classes to outputs
+        if "output_types" in result and not result.get("outputs"):
+            for base_class in result["output_types"]:
+                output = Output(
+                    display_name=base_class,
+                    name=base_class.lower(),
+                    types=[base_class],
+                    selected=base_class,
+                )
+                result["outputs"].append(output.model_dump())
+
+        return {name: result}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FrontendNode":
+        if "template" in data:
+            data["template"] = Template.from_dict(data["template"])
+        return cls(**data)
+
+    # For backwards compatibility
+    def to_dict(self, *, keep_name=True) -> dict:
+        """Returns a dict representation of the frontend node."""
+        dump = self.model_dump(by_alias=True, exclude_none=True)
+        if not keep_name:
+            return dump.pop(self.name)
+        return dump
+
+    def add_extra_fields(self) -> None:
+        pass
+
+    def add_extra_base_classes(self) -> None:
+        pass
+
+    def set_base_classes_from_outputs(self) -> None:
+        self.base_classes = [output_type for output in self.outputs for output_type in output.types]
+
+    def validate_component(self) -> None:
+        self.validate_name_overlap()
+        self.validate_attributes()
+
+    def validate_name_overlap(self) -> None:
+        # Check if any of the output names overlap with the any of the inputs
+        output_names = [output.name for output in self.outputs if not output.allows_loop]
+        input_names = [input_.name for input_ in self.template.fields]
+        overlap = set(output_names).intersection(input_names)
+        if overlap:
+            overlap_str = ", ".join(f"'{x}'" for x in overlap)
+            msg = (
+                "There should be no overlap between input and output names. "
+                f"Names {overlap_str} are duplicated in component {self.display_name}. "
+                f"Inputs are {input_names} and outputs are {output_names}."
+            )
+            raise ValueError(msg)
+
+    def validate_attributes(self) -> None:
+        # None of inputs, outputs, _artifacts, _results, logs, status, vertex, graph, display_name, description,
+        # documentation, icon should be present in outputs or input names
+        output_names = [output.name for output in self.outputs]
+        input_names = [input_.name for input_ in self.template.fields]
+        attributes = [
+            "inputs",
+            "outputs",
+            "_artifacts",
+            "_results",
+            "logs",
+            "status",
+            "vertex",
+            "graph",
+            "display_name",
+            "description",
+            "documentation",
+            "icon",
+        ]
+        output_overlap = set(output_names).intersection(attributes)
+        input_overlap = set(input_names).intersection(attributes)
+        error_message = ""
+        if output_overlap:
+            output_overlap_str = ", ".join(f"'{x}'" for x in output_overlap)
+            error_message += f"Output names {output_overlap_str} are reserved attributes.\n"
+        if input_overlap:
+            input_overlap_str = ", ".join(f"'{x}'" for x in input_overlap)
+            error_message += f"Input names {input_overlap_str} are reserved attributes."
+
+    def add_base_class(self, base_class: str | list[str]) -> None:
+        """Adds a base class to the frontend node."""
+        if isinstance(base_class, str):
+            self.base_classes.append(base_class)
+        elif isinstance(base_class, list):
+            self.base_classes.extend(base_class)
+
+    def add_output_type(self, output_type: str | list[str]) -> None:
+        """Adds an output type to the frontend node."""
+        if isinstance(output_type, str):
+            self.output_types.append(output_type)
+        elif isinstance(output_type, list):
+            self.output_types.extend(output_type)
+
+    @classmethod
+    def from_inputs(cls, **kwargs):
+        """Create a frontend node from inputs."""
+        if "inputs" not in kwargs:
+            msg = "Missing 'inputs' argument."
+            raise ValueError(msg)
+        if "_outputs_map" in kwargs:
+            kwargs["outputs"] = kwargs.pop("_outputs_map")
+        inputs = kwargs.pop("inputs")
+        template = Template(type_name="Component", fields=inputs)
+        kwargs["template"] = template
+        return cls(**kwargs)
+
+    def set_field_value_in_template(self, field_name, value) -> None:
+        for idx, field in enumerate(self.template.fields):
+            if field.name == field_name:
+                new_field = field.model_copy()
+                new_field.value = value
+                self.template.fields[idx] = new_field
+                break
+
+    def set_field_load_from_db_in_template(self, field_name, value) -> None:
+        for idx, field in enumerate(self.template.fields):
+            if field.name == field_name and hasattr(field, "load_from_db"):
+                new_field = field.model_copy()
+                new_field.load_from_db = value
+                self.template.fields[idx] = new_field
+                break

lfx/template/frontend_node/constants.py

@@ -0,0 +1,65 @@
+FORCE_SHOW_FIELDS = [
+    "allowed_tools",
+    "memory",
+    "prefix",
+    "examples",
+    "temperature",
+    "model_name",
+    "headers",
+    "max_value_length",
+    "max_tokens",
+    "google_cse_id",
+]
+
+DEFAULT_PROMPT = """
+I want you to act as a naming consultant for new companies.
+
+Here are some examples of good company names:
+
+- search engine, Google
+- social media, Facebook
+- video sharing, YouTube
+
+The name should be short, catchy and easy to remember.
+
+What is a good name for a company that makes {product}?
+"""
+
+SYSTEM_PROMPT = """
+You are a helpful assistant that talks casually about life in general.
+You are a good listener and you can talk about anything.
+"""
+
+HUMAN_PROMPT = "{input}"
+
+QA_CHAIN_TYPES = ["stuff", "map_reduce", "map_rerank", "refine"]
+
+CTRANSFORMERS_DEFAULT_CONFIG = {
+    "top_k": 40,
+    "top_p": 0.95,
+    "temperature": 0.8,
+    "repetition_penalty": 1.1,
+    "last_n_tokens": 64,
+    "seed": -1,
+    "max_new_tokens": 256,
+    "stop": None,
+    "stream": False,
+    "reset": True,
+    "batch_size": 8,
+    "threads": -1,
+    "context_length": -1,
+    "gpu_layers": 0,
+}
+
+# This variable is used to tell the user
+# that it can be changed to use other APIs
+# like Prem and LocalAI
+OPENAI_API_BASE_INFO = """
+The base URL of the OpenAI API. Defaults to https://api.openai.com/v1.
+
+You can change this to use other APIs like JinaChat, LocalAI and Prem.
+"""
+
+
+INPUT_KEY_INFO = """The variable to be used as Chat Input when more than one variable is available."""
+OUTPUT_KEY_INFO = """The variable to be used as Chat Output (e.g. answer in a ConversationalRetrievalChain)"""

lfx/template/frontend_node/custom_components.py

@@ -0,0 +1,79 @@
+from lfx.template.field.base import Input
+from lfx.template.frontend_node.base import FrontendNode
+from lfx.template.template.base import Template
+
+DEFAULT_CUSTOM_COMPONENT_CODE = """from lfx.custom import CustomComponent
+
+from typing import Optional, List, Dict, Union
+from lfx.field_typing import (
+    Tool,
+)
+from lfx.schema.data import Data
+
+
+class Component(CustomComponent):
+    display_name: str = "Custom Component"
+    description: str = "Create any custom component you want!"
+
+    def build_config(self):
+        return {"param": {"display_name": "Parameter"}}
+
+    def build(self, param: Data) -> Data:
+        return param
+
+"""
+
+
+class CustomComponentFrontendNode(FrontendNode):
+    _format_template: bool = False
+    name: str = "CustomComponent"
+    display_name: str | None = "CustomComponent"
+    beta: bool = False
+    legacy: bool = False
+    minimized: bool = False
+    template: Template = Template(
+        type_name="CustomComponent",
+        fields=[
+            Input(
+                field_type="code",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                value=DEFAULT_CUSTOM_COMPONENT_CODE,
+                name="code",
+                advanced=False,
+                dynamic=True,
+            )
+        ],
+    )
+    description: str | None = None
+    base_classes: list[str] = []
+    last_updated: str | None = None
+
+
+class ComponentFrontendNode(FrontendNode):
+    _format_template: bool = False
+    name: str = "Component"
+    display_name: str | None = "Component"
+    beta: bool = False
+    minimized: bool = False
+    legacy: bool = False
+    template: Template = Template(
+        type_name="Component",
+        fields=[
+            Input(
+                field_type="code",
+                required=True,
+                placeholder="",
+                is_list=False,
+                show=True,
+                value=DEFAULT_CUSTOM_COMPONENT_CODE,
+                name="code",
+                advanced=False,
+                dynamic=True,
+            )
+        ],
+    )
+    description: str | None = None
+    base_classes: list[str] = []