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

lfx/graph/schema.py

@@ -0,0 +1,75 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field, field_serializer, model_validator
+
+from lfx.schema.schema import OutputValue, StreamURL
+from lfx.serialization.serialization import serialize
+from lfx.utils.schemas import ChatOutputResponse, ContainsEnumMeta
+
+
+class ResultData(BaseModel):
+    results: Any | None = Field(default_factory=dict)
+    artifacts: Any | None = Field(default_factory=dict)
+    outputs: dict | None = Field(default_factory=dict)
+    logs: dict | None = Field(default_factory=dict)
+    messages: list[ChatOutputResponse] | None = Field(default_factory=list)
+    timedelta: float | None = None
+    duration: str | None = None
+    component_display_name: str | None = None
+    component_id: str | None = None
+    used_frozen_result: bool | None = False
+
+    @field_serializer("results")
+    def serialize_results(self, value):
+        if isinstance(value, dict):
+            return {key: serialize(val) for key, val in value.items()}
+        return serialize(value)
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_model(cls, values):
+        if not values.get("outputs") and values.get("artifacts"):
+            # Build the log from the artifacts
+
+            for key in values["artifacts"]:
+                message = values["artifacts"][key]
+
+                # ! Temporary fix
+                if message is None:
+                    continue
+
+                if "stream_url" in message and "type" in message:
+                    stream_url = StreamURL(location=message["stream_url"])
+                    values["outputs"].update({key: OutputValue(message=stream_url, type=message["type"])})
+                elif "type" in message:
+                    values["outputs"].update({key: OutputValue(message=message, type=message["type"])})
+        return values
+
+
+class InterfaceComponentTypes(str, Enum, metaclass=ContainsEnumMeta):
+    ChatInput = "ChatInput"
+    ChatOutput = "ChatOutput"
+    TextInput = "TextInput"
+    TextOutput = "TextOutput"
+    DataOutput = "DataOutput"
+    WebhookInput = "Webhook"
+
+
+CHAT_COMPONENTS = [InterfaceComponentTypes.ChatInput, InterfaceComponentTypes.ChatOutput]
+RECORDS_COMPONENTS = [InterfaceComponentTypes.DataOutput]
+INPUT_COMPONENTS = [
+    InterfaceComponentTypes.ChatInput,
+    InterfaceComponentTypes.WebhookInput,
+    InterfaceComponentTypes.TextInput,
+]
+OUTPUT_COMPONENTS = [
+    InterfaceComponentTypes.ChatOutput,
+    InterfaceComponentTypes.DataOutput,
+    InterfaceComponentTypes.TextOutput,
+]
+
+
+class RunOutputs(BaseModel):
+    inputs: dict = Field(default_factory=dict)
+    outputs: list[ResultData | None] = Field(default_factory=list)

lfx/graph/state/model.py

@@ -0,0 +1,237 @@
+from collections.abc import Callable
+from typing import Any, get_type_hints
+
+from pydantic import ConfigDict, computed_field, create_model
+from pydantic.fields import FieldInfo
+
+
+def __validate_method(method: Callable) -> None:
+    """Validates a method by checking if it has the required attributes.
+
+    This function ensures that the given method belongs to a class with the necessary
+    structure for output handling. It checks for the presence of a __self__ attribute
+    on the method and a get_output_by_method attribute on the method's class.
+
+    Args:
+        method (Callable): The method to be validated.
+
+    Raises:
+        ValueError: If the method does not have a __self__ attribute or if the method's
+                    class does not have a get_output_by_method attribute.
+
+    Example:
+        >>> class ValidClass:
+        ...     def get_output_by_method(self):
+        ...         pass
+        ...     def valid_method(self):
+        ...         pass
+        >>> __validate_method(ValidClass().valid_method)  # This will pass
+        >>> __validate_method(lambda x: x)  # This will raise a ValueError
+    """
+    if not hasattr(method, "__self__"):
+        msg = f"Method {method} does not have a __self__ attribute."
+        raise ValueError(msg)
+    if not hasattr(method.__self__, "get_output_by_method"):
+        msg = f"Method's class {method.__self__} must have a get_output_by_method attribute."
+        raise ValueError(msg)
+
+
+def build_output_getter(method: Callable, *, validate: bool = True) -> Callable:
+    """Builds an output getter function for a given method in a graph component.
+
+    This function creates a new callable that, when invoked, retrieves the output
+    of the specified method using the get_output_by_method of the method's class.
+    It's used in creating dynamic state models for graph components.
+
+    Args:
+        method (Callable): The method for which to build the output getter.
+        validate (bool, optional): Whether to validate the method before building
+                                   the getter. Defaults to True.
+
+    Returns:
+        Callable: The output getter function. When called, this function returns
+                  the value of the output associated with the original method.
+
+    Raises:
+        ValueError: If the method has no return type annotation or if validation fails.
+
+    Notes:
+        - The getter function returns UNDEFINED if the output has not been set.
+        - When validate is True, the method must belong to a class with a
+          'get_output_by_method' attribute.
+        - This function is typically used internally by create_state_model.
+
+    Example:
+        >>> class ChatComponent:
+        ...     def get_output_by_method(self, method):
+        ...         return type('Output', (), {'value': "Hello, World!"})()
+        ...     def get_message(self) -> str:
+        ...         pass
+        >>> component = ChatComponent()
+        >>> getter = build_output_getter(component.get_message)
+        >>> print(getter(None))  # This will print "Hello, World!"
+    """
+
+    def output_getter(_):
+        if validate:
+            __validate_method(method)
+        methods_class = method.__self__
+        output = methods_class.get_output_by_method(method)
+        return output.value
+
+    return_type = get_type_hints(method).get("return", None)
+
+    if return_type is None:
+        msg = f"Method {method.__name__} has no return type annotation."
+        raise ValueError(msg)
+    output_getter.__annotations__["return"] = return_type
+    return output_getter
+
+
+def build_output_setter(method: Callable, *, validate: bool = True) -> Callable:
+    """Build an output setter function for a given method in a graph component.
+
+    This function creates a new callable that, when invoked, sets the output
+    of the specified method using the get_output_by_method of the method's class.
+    It's used in creating dynamic state models for graph components, allowing
+    for the modification of component states.
+
+    Args:
+        method (Callable): The method for which the output setter is being built.
+        validate (bool, optional): Flag indicating whether to validate the method
+                                   before building the setter. Defaults to True.
+
+    Returns:
+        Callable: The output setter function. When called with a value, this function
+                  sets the output associated with the original method to that value.
+
+    Raises:
+        ValueError: If validation fails when validate is True.
+
+    Notes:
+        - When validate is True, the method must belong to a class with a
+          'get_output_by_method' attribute.
+        - This function is typically used internally by create_state_model.
+        - The setter allows for dynamic updating of component states in a graph.
+
+    Example:
+        >>> class ChatComponent:
+        ...     def get_output_by_method(self, method):
+        ...         return type('Output', (), {'value': None})()
+        ...     def set_message(self):
+        ...         pass
+        >>> component = ChatComponent()
+        >>> setter = build_output_setter(component.set_message)
+        >>> setter(component, "New message")
+        >>> print(component.get_output_by_method(component.set_message).value)  # Prints "New message"
+    """
+
+    def output_setter(self, value) -> None:  # noqa: ARG001
+        if validate:
+            __validate_method(method)
+        methods_class = method.__self__  # type: ignore[attr-defined]
+        output = methods_class.get_output_by_method(method)
+        output.value = value
+
+    return output_setter
+
+
+def create_state_model(model_name: str = "State", *, validate: bool = True, **kwargs) -> type:
+    """Create a dynamic Pydantic state model based on the provided keyword arguments.
+
+    This function generates a Pydantic model class with fields corresponding to the
+    provided keyword arguments. It can handle various types of field definitions,
+    including callable methods (which are converted to properties), FieldInfo objects,
+    and type-default value tuples.
+
+    Args:
+        model_name (str, optional): The name of the model. Defaults to "State".
+        validate (bool, optional): Whether to validate the methods when converting
+                                   them to properties. Defaults to True.
+        **kwargs: Keyword arguments representing the fields of the model. Each argument
+                  can be a callable method, a FieldInfo object, or a tuple of (type, default).
+
+    Returns:
+        type: The dynamically created Pydantic state model class.
+
+    Raises:
+        ValueError: If the provided field value is invalid or cannot be processed.
+
+    Examples:
+        >>> from lfx.components.io import ChatInput
+        >>> from lfx.components.io.ChatOutput import ChatOutput
+        >>> from pydantic import Field
+        >>>
+        >>> chat_input = ChatInput()
+        >>> chat_output = ChatOutput()
+        >>>
+        >>> # Create a model with a method from a component
+        >>> StateModel = create_state_model(method_one=chat_input.message_response)
+        >>> state = StateModel()
+        >>> assert state.method_one is UNDEFINED
+        >>> chat_input.set_output_value("message", "test")
+        >>> assert state.method_one == "test"
+        >>>
+        >>> # Create a model with multiple components and a Pydantic Field
+        >>> NewStateModel = create_state_model(
+        ...     model_name="NewStateModel",
+        ...     first_method=chat_input.message_response,
+        ...     second_method=chat_output.message_response,
+        ...     my_attribute=Field(None)
+        ... )
+        >>> new_state = NewStateModel()
+        >>> new_state.first_method = "test"
+        >>> new_state.my_attribute = 123
+        >>> assert new_state.first_method == "test"
+        >>> assert new_state.my_attribute == 123
+        >>>
+        >>> # Create a model with tuple-based field definitions
+        >>> TupleStateModel = create_state_model(field_one=(str, "default"), field_two=(int, 123))
+        >>> tuple_state = TupleStateModel()
+        >>> assert tuple_state.field_one == "default"
+        >>> assert tuple_state.field_two == 123
+
+    Notes:
+        - The function handles empty keyword arguments gracefully.
+        - For tuple-based field definitions, the first element must be a valid Python type.
+        - Unsupported value types in keyword arguments will raise a ValueError.
+        - Callable methods must have proper return type annotations and belong to a class
+          with a 'get_output_by_method' attribute when validate is True.
+    """
+    fields = {}
+
+    for name, value in kwargs.items():
+        # Extract the return type from the method's type annotations
+        if callable(value):
+            # Define the field with the return type
+            try:
+                __validate_method(value)
+                getter = build_output_getter(value, validate=validate)
+                setter = build_output_setter(value, validate=validate)
+                property_method = property(getter, setter)
+            except ValueError as e:
+                # If the method is not valid,assume it is already a getter
+                if ("get_output_by_method" not in str(e) and "__self__" not in str(e)) or validate:
+                    raise
+                property_method = value
+            fields[name] = computed_field(property_method)
+        elif isinstance(value, FieldInfo):
+            field_tuple = (value.annotation or Any, value)
+            fields[name] = field_tuple
+        elif isinstance(value, tuple) and len(value) == 2:  # noqa: PLR2004
+            # Fields are defined by one of the following tuple forms:
+
+            # (<type>, <default value>)
+            # (<type>, Field(...))
+            # typing.Annotated[<type>, Field(...)]
+            if not isinstance(value[0], type):
+                msg = f"Invalid type for field {name}: {type(value[0])}"
+                raise TypeError(msg)
+            fields[name] = (value[0], value[1])
+        else:
+            msg = f"Invalid value type {type(value)} for field {name}"
+            raise ValueError(msg)
+
+    # Create the model dynamically
+    config_dict = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True)
+    return create_model(model_name, __config__=config_dict, **fields)

lfx/graph/utils.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+from uuid import UUID
+
+from lfx.interface.utils import extract_input_variables_from_prompt
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+# Database imports removed - lfx should be lightweight
+from lfx.services.deps import get_db_service, get_settings_service
+
+if TYPE_CHECKING:
+    from lfx.graph.vertex.base import Vertex
+
+
+class UnbuiltObject:
+    pass
+
+
+class UnbuiltResult:
+    pass
+
+
+class ArtifactType(str, Enum):
+    TEXT = "text"
+    RECORD = "record"
+    OBJECT = "object"
+    ARRAY = "array"
+    STREAM = "stream"
+    UNKNOWN = "unknown"
+    MESSAGE = "message"
+
+
+def validate_prompt(prompt: str):
+    """Validate prompt."""
+    if extract_input_variables_from_prompt(prompt):
+        return prompt
+
+    return fix_prompt(prompt)
+
+
+def fix_prompt(prompt: str):
+    """Fix prompt."""
+    return prompt + " {input}"
+
+
+def flatten_list(list_of_lists: list[list | Any]) -> list:
+    """Flatten list of lists."""
+    new_list = []
+    for item in list_of_lists:
+        if isinstance(item, list):
+            new_list.extend(item)
+        else:
+            new_list.append(item)
+    return new_list
+
+
+def get_artifact_type(value, build_result) -> str:
+    result = ArtifactType.UNKNOWN
+    match value:
+        case Data():
+            result = ArtifactType.RECORD
+
+        case str():
+            result = ArtifactType.TEXT
+
+        case dict():
+            result = ArtifactType.OBJECT
+
+        case list():
+            result = ArtifactType.ARRAY
+
+        case Message():
+            result = ArtifactType.MESSAGE
+
+    if result == ArtifactType.UNKNOWN and (
+        isinstance(build_result, Generator) or (isinstance(value, Message) and isinstance(value.text, Generator))
+    ):
+        result = ArtifactType.STREAM
+
+    return result.value
+
+
+def post_process_raw(raw, artifact_type: str):
+    if artifact_type == ArtifactType.STREAM.value:
+        raw = ""
+
+    return raw
+
+
+def _vertex_to_primitive_dict(target: Vertex) -> dict:
+    """Cleans the parameters of the target vertex."""
+    # Removes all keys that the values aren't python types like str, int, bool, etc.
+    params = {
+        key: value for key, value in target.params.items() if isinstance(value, str | int | bool | float | list | dict)
+    }
+    # if it is a list we need to check if the contents are python types
+    for key, value in params.items():
+        if isinstance(value, list):
+            params[key] = [item for item in value if isinstance(item, str | int | bool | float | list | dict)]
+    return params
+
+
+async def log_transaction(
+    flow_id: str | UUID,
+    source: Vertex,
+    status,
+    target: Vertex | None = None,  # noqa: ARG001
+    error=None,  # noqa: ARG001
+) -> None:
+    """Asynchronously logs a transaction record for a vertex in a flow if transaction storage is enabled.
+
+    This is a lightweight implementation that only logs if database service is available.
+    """
+    try:
+        settings_service = get_settings_service()
+        if not settings_service or not getattr(settings_service.settings, "transactions_storage_enabled", False):
+            return
+
+        db_service = get_db_service()
+        if db_service is None:
+            logger.debug("Database service not available, skipping transaction logging")
+            return
+
+        if not flow_id:
+            if source.graph.flow_id:
+                flow_id = source.graph.flow_id
+            else:
+                return
+
+        # Log basic transaction info - concrete implementation should be in langflow
+        logger.debug(f"Transaction logged: vertex={source.id}, flow={flow_id}, status={status}")
+    except Exception as exc:  # noqa: BLE001
+        logger.debug(f"Error logging transaction: {exc!s}")
+
+
+async def log_vertex_build(
+    *,
+    flow_id: str | UUID,
+    vertex_id: str,
+    valid: bool,
+    params: Any,  # noqa: ARG001
+    data: dict | Any,  # noqa: ARG001
+    artifacts: dict | None = None,  # noqa: ARG001
+) -> None:
+    """Asynchronously logs a vertex build record if vertex build storage is enabled.
+
+    This is a lightweight implementation that only logs if database service is available.
+    """
+    try:
+        settings_service = get_settings_service()
+        if not settings_service or not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
+            return
+
+        db_service = get_db_service()
+        if db_service is None:
+            logger.debug("Database service not available, skipping vertex build logging")
+            return
+
+        try:
+            if isinstance(flow_id, str):
+                flow_id = UUID(flow_id)
+        except ValueError:
+            logger.debug(f"Invalid flow_id passed to log_vertex_build: {flow_id!r}")
+            return
+
+        # Log basic vertex build info - concrete implementation should be in langflow
+        logger.debug(f"Vertex build logged: vertex={vertex_id}, flow={flow_id}, valid={valid}")
+    except Exception:  # noqa: BLE001
+        logger.debug("Error logging vertex build")
+
+
+def rewrite_file_path(file_path: str):
+    file_path = file_path.replace("\\", "/")
+
+    if ":" in file_path:
+        file_path = file_path.split(":", 1)[-1]
+
+    file_path_split = [part for part in file_path.split("/") if part]
+
+    if len(file_path_split) > 1:
+        consistent_file_path = f"{file_path_split[-2]}/{file_path_split[-1]}"
+    else:
+        consistent_file_path = "/".join(file_path_split)
+
+    return [consistent_file_path]
+
+
+def has_output_vertex(vertices: dict[Vertex, int]):
+    return any(vertex.is_output for vertex in vertices)
+
+
+def has_chat_output(vertices: dict[Vertex, int]):
+    from lfx.graph.schema import InterfaceComponentTypes
+
+    return any(InterfaceComponentTypes.ChatOutput in vertex.id for vertex in vertices)