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

langflow/graph/schema.py

@@ -1,75 +0,0 @@
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel, Field, field_serializer, model_validator
-
-from langflow.schema.schema import OutputValue, StreamURL
-from langflow.serialization.serialization import serialize
-from langflow.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)

langflow/graph/state/model.py

@@ -1,237 +0,0 @@
-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 langflow.components.io import ChatInput
-        >>> from langflow.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)

langflow/graph/utils.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Generator
-from enum import Enum
-from typing import TYPE_CHECKING, Any
-from uuid import UUID
-
-import pandas as pd
-
-from langflow.interface.utils import extract_input_variables_from_prompt
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-from langflow.serialization.serialization import get_max_items_length, get_max_text_length, serialize
-from langflow.services.database.models.transactions.crud import log_transaction as crud_log_transaction
-from langflow.services.database.models.transactions.model import TransactionBase
-from langflow.services.database.models.vertex_builds.crud import log_vertex_build as crud_log_vertex_build
-from langflow.services.database.models.vertex_builds.model import VertexBuildBase
-from langflow.services.database.utils import session_getter
-from langflow.services.deps import get_db_service, get_settings_service
-
-if TYPE_CHECKING:
-    from langflow.api.v1.schemas import ResultDataResponse
-    from langflow.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, error=None
-) -> None:
-    """Asynchronously logs a transaction record for a vertex in a flow if transaction storage is enabled.
-
-    Serializes the source vertex's primitive parameters and result, handling pandas DataFrames as needed,
-    and records transaction details including inputs, outputs, status, error, and flow ID in the database.
-    If the flow ID is not provided, attempts to retrieve it from the source vertex's graph.
-    Logs warnings and errors on serialization or database failures.
-    """
-    try:
-        if not get_settings_service().settings.transactions_storage_enabled:
-            return
-        if not flow_id:
-            if source.graph.flow_id:
-                flow_id = source.graph.flow_id
-            else:
-                return
-        inputs = _vertex_to_primitive_dict(source)
-
-        # Convert the result to a serializable format
-        if source.result:
-            try:
-                result_dict = source.result.model_dump()
-                for key, value in result_dict.items():
-                    if isinstance(value, pd.DataFrame):
-                        result_dict[key] = value.to_dict()
-                outputs = result_dict
-            except Exception as e:  # noqa: BLE001
-                await logger.awarning(f"Error serializing result: {e!s}")
-                outputs = None
-        else:
-            outputs = None
-
-        transaction = TransactionBase(
-            vertex_id=source.id,
-            target_id=target.id if target else None,
-            inputs=serialize(inputs, max_length=get_max_text_length(), max_items=get_max_items_length()),
-            outputs=serialize(outputs, max_length=get_max_text_length(), max_items=get_max_items_length()),
-            status=status,
-            error=error,
-            flow_id=flow_id if isinstance(flow_id, UUID) else UUID(flow_id),
-        )
-        async with session_getter(get_db_service()) as session:
-            with session.no_autoflush:
-                inserted = await crud_log_transaction(session, transaction)
-                if inserted:
-                    await logger.adebug(f"Logged transaction: {inserted.id}")
-    except Exception as exc:  # noqa: BLE001
-        await logger.aerror(f"Error logging transaction: {exc!s}")
-
-
-async def log_vertex_build(
-    *,
-    flow_id: str | UUID,
-    vertex_id: str,
-    valid: bool,
-    params: Any,
-    data: ResultDataResponse | dict,
-    artifacts: dict | None = None,
-) -> None:
-    """Asynchronously logs a vertex build record to the database if vertex build storage is enabled.
-
-    Serializes the provided data and artifacts with configurable length and item limits before storing.
-    Converts parameters to string if present. Handles exceptions by logging errors.
-    """
-    try:
-        if not get_settings_service().settings.vertex_builds_storage_enabled:
-            return
-        try:
-            if isinstance(flow_id, str):
-                flow_id = UUID(flow_id)
-        except ValueError:
-            msg = f"Invalid flow_id passed to log_vertex_build: {flow_id!r}(type: {type(flow_id)})"
-            raise ValueError(msg) from None
-
-        vertex_build = VertexBuildBase(
-            flow_id=flow_id,
-            id=vertex_id,
-            valid=valid,
-            params=str(params) if params else None,
-            data=serialize(data, max_length=get_max_text_length(), max_items=get_max_items_length()),
-            artifacts=serialize(artifacts, max_length=get_max_text_length(), max_items=get_max_items_length()),
-        )
-        async with session_getter(get_db_service()) as session:
-            inserted = await crud_log_vertex_build(session, vertex_build)
-            await logger.adebug(f"Logged vertex build: {inserted.build_id}")
-    except Exception:  # noqa: BLE001
-        await logger.aexception("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 langflow.graph.schema import InterfaceComponentTypes
-
-    return any(InterfaceComponentTypes.ChatOutput in vertex.id for vertex in vertices)