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

lfx/memory/stubs.py

@@ -0,0 +1,283 @@
+"""Memory management functions for lfx package.
+
+This module provides message storage and retrieval functionality adapted for lfx's
+service-based architecture. It mirrors the langflow.memory API but works with
+lfx's Message model and service interfaces.
+"""
+
+from uuid import UUID
+
+from lfx.log.logger import logger
+from lfx.schema.message import Message
+from lfx.services.deps import session_scope
+from lfx.utils.async_helpers import run_until_complete
+
+
+async def astore_message(
+    message: Message,
+    flow_id: str | UUID | None = None,
+) -> list[Message]:
+    """Store a message in the memory.
+
+    Args:
+        message (Message): The message to store.
+        flow_id (Optional[str | UUID]): The flow ID associated with the message.
+            When running from the CustomComponent you can access this using `self.graph.flow_id`.
+
+    Returns:
+        List[Message]: A list containing the stored message.
+
+    Raises:
+        ValueError: If any of the required parameters (session_id, sender, sender_name) is not provided.
+    """
+    if not message:
+        logger.warning("No message provided.")
+        return []
+
+    if not message.session_id or not message.sender or not message.sender_name:
+        msg = (
+            f"All of session_id, sender, and sender_name must be provided. Session ID: {message.session_id},"
+            f" Sender: {message.sender}, Sender Name: {message.sender_name}"
+        )
+        raise ValueError(msg)
+
+    # Set flow_id if provided
+    if flow_id:
+        if isinstance(flow_id, str):
+            flow_id = UUID(flow_id)
+        message.flow_id = str(flow_id)
+
+    # In lfx, we use the service architecture - this is a simplified implementation
+    # that doesn't persist to database but maintains the message in memory
+    # Real implementation would require a database service
+    async with session_scope() as session:
+        # Since we're using NoopSession by default, this doesn't actually persist
+        # but maintains the same interface as langflow.memory
+        try:
+            # Generate an ID if not present
+            if not hasattr(message, "id") or not message.id:
+                try:
+                    import nanoid
+
+                    message.id = nanoid.generate()
+                except ImportError:
+                    # Fallback to uuid if nanoid is not available
+                    import uuid
+
+                    message.id = str(uuid.uuid4())
+
+            await session.add(message)
+            await session.commit()
+            logger.debug(f"Message stored with ID: {message.id}")
+        except Exception as e:
+            logger.exception(f"Error storing message: {e}")
+            await session.rollback()
+            raise
+        return [message]
+
+
+def store_message(
+    message: Message,
+    flow_id: str | UUID | None = None,
+) -> list[Message]:
+    """DEPRECATED: Stores a message in the memory.
+
+    DEPRECATED: Use `astore_message` instead.
+
+    Args:
+        message (Message): The message to store.
+        flow_id (Optional[str | UUID]): The flow ID associated with the message.
+            When running from the CustomComponent you can access this using `self.graph.flow_id`.
+
+    Returns:
+        List[Message]: A list containing the stored message.
+
+    Raises:
+        ValueError: If any of the required parameters (session_id, sender, sender_name) is not provided.
+    """
+    return run_until_complete(astore_message(message, flow_id=flow_id))
+
+
+async def aupdate_messages(messages: Message | list[Message]) -> list[Message]:
+    """Update stored messages.
+
+    Args:
+        messages: Message or list of messages to update.
+
+    Returns:
+        List[Message]: Updated messages.
+
+    Raises:
+        ValueError: If message is not found for update.
+    """
+    if not isinstance(messages, list):
+        messages = [messages]
+
+    async with session_scope() as session:
+        updated_messages: list[Message] = []
+        for message in messages:
+            try:
+                # In a real implementation, this would update the database record
+                # For now, we just validate the message has an ID and return it
+                if not hasattr(message, "id") or not message.id:
+                    error_message = f"Message without ID cannot be updated: {message}"
+                    logger.warning(error_message)
+                    raise ValueError(error_message)
+
+                # Convert flow_id to string if it's a UUID
+                if message.flow_id and isinstance(message.flow_id, UUID):
+                    message.flow_id = str(message.flow_id)
+
+                await session.add(message)
+                await session.commit()
+                await session.refresh(message)
+                updated_messages.append(message)
+                logger.debug(f"Message updated: {message.id}")
+            except Exception as e:
+                logger.exception(f"Error updating message: {e}")
+                await session.rollback()
+                msg = f"Failed to update message: {e}"
+                logger.error(msg)
+                raise ValueError(msg) from e
+
+        return updated_messages
+
+
+async def delete_message(id_: str) -> None:
+    """Delete a message from the memory.
+
+    Args:
+        id_ (str): The ID of the message to delete.
+    """
+    async with session_scope() as session:
+        try:
+            # In a real implementation, this would delete from database
+            # For now, this is a no-op since we're using NoopSession
+            await session.delete(id_)
+            await session.commit()
+            logger.debug(f"Message deleted: {id_}")
+        except Exception as e:
+            logger.exception(f"Error deleting message: {e}")
+            raise
+
+
+async def aget_messages(
+    sender: str | None = None,  # noqa: ARG001
+    sender_name: str | None = None,  # noqa: ARG001
+    session_id: str | UUID | None = None,  # noqa: ARG001
+    order_by: str | None = "timestamp",  # noqa: ARG001
+    order: str | None = "DESC",  # noqa: ARG001
+    flow_id: UUID | None = None,  # noqa: ARG001
+    limit: int | None = None,  # noqa: ARG001
+) -> list[Message]:
+    """Retrieve messages based on the provided filters.
+
+    Args:
+        sender (Optional[str]): The sender of the messages (e.g., "Machine" or "User")
+        sender_name (Optional[str]): The name of the sender.
+        session_id (Optional[str]): The session ID associated with the messages.
+        order_by (Optional[str]): The field to order the messages by. Defaults to "timestamp".
+        order (Optional[str]): The order in which to retrieve the messages. Defaults to "DESC".
+        flow_id (Optional[UUID]): The flow ID associated with the messages.
+        limit (Optional[int]): The maximum number of messages to retrieve.
+
+    Returns:
+        List[Message]: A list of Message objects representing the retrieved messages.
+    """
+    async with session_scope() as session:
+        try:
+            # In a real implementation, this would query the database
+            # For now, return empty list since we're using NoopSession
+            result = await session.query()  # This returns [] from NoopSession
+            logger.debug(f"Retrieved {len(result)} messages")
+        except Exception as e:  # noqa: BLE001
+            logger.exception(f"Error retrieving messages: {e}")
+            return []
+        return result
+
+
+def get_messages(
+    sender: str | None = None,
+    sender_name: str | None = None,
+    session_id: str | UUID | None = None,
+    order_by: str | None = "timestamp",
+    order: str | None = "DESC",
+    flow_id: UUID | None = None,
+    limit: int | None = None,
+) -> list[Message]:
+    """DEPRECATED - Retrieve messages based on the provided filters.
+
+    DEPRECATED: Use `aget_messages` instead.
+    """
+    return run_until_complete(aget_messages(sender, sender_name, session_id, order_by, order, flow_id, limit))
+
+
+async def adelete_messages(session_id: str) -> None:
+    """Delete messages from the memory based on the provided session ID.
+
+    Args:
+        session_id (str): The session ID associated with the messages to delete.
+    """
+    async with session_scope() as session:
+        try:
+            # In a real implementation, this would delete from database
+            # For now, this is a no-op since we're using NoopSession
+            await session.delete(session_id)
+            await session.commit()
+            logger.debug(f"Messages deleted for session: {session_id}")
+        except Exception as e:
+            logger.exception(f"Error deleting messages: {e}")
+            raise
+
+
+def delete_messages(session_id: str) -> None:
+    """DEPRECATED - Delete messages based on the provided session ID.
+
+    DEPRECATED: Use `adelete_messages` instead.
+    """
+    return run_until_complete(adelete_messages(session_id))
+
+
+async def aadd_messages(messages: Message | list[Message]) -> list[Message]:
+    """Add messages to the memory.
+
+    Args:
+        messages: Message or list of messages to add.
+
+    Returns:
+        List[Message]: Added messages.
+    """
+    if not isinstance(messages, list):
+        messages = [messages]
+
+    result = []
+    for message in messages:
+        stored = await astore_message(message)
+        result.extend(stored)
+    return result
+
+
+def add_messages(messages: Message | list[Message]) -> list[Message]:
+    """Add messages to the memory (synchronous version).
+
+    Args:
+        messages: Message or list of messages to add.
+
+    Returns:
+        List[Message]: Added messages.
+    """
+    return run_until_complete(aadd_messages(messages))
+
+
+async def aadd_messagetables(messages: Message | list[Message]) -> list[Message]:
+    """Add message tables to the memory.
+
+    This is an alias for aadd_messages for backwards compatibility.
+
+    Args:
+        messages: Message or list of messages to add.
+
+    Returns:
+        List[Message]: Added messages.
+    """
+    return await aadd_messages(messages)

lfx/processing/__init__.py

@@ -0,0 +1 @@
+"""Processing module for lfx package."""

lfx/processing/process.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, cast
+
+from json_repair import repair_json
+from pydantic import BaseModel
+
+from lfx.graph.vertex.base import Vertex
+from lfx.log.logger import logger
+from lfx.schema.graph import InputValue, Tweaks
+from lfx.schema.schema import INPUT_FIELD_NAME, InputValueRequest
+from lfx.services.deps import get_settings_service
+
+if TYPE_CHECKING:
+    from lfx.events.event_manager import EventManager
+    from lfx.graph.graph.base import Graph
+    from lfx.graph.schema import RunOutputs
+
+
+def validate_and_repair_json(json_str: str | dict) -> dict[str, Any] | str:
+    """Validates a JSON string and attempts to repair it if invalid.
+
+    Args:
+        json_str (str): The JSON string to validate/repair
+
+    Returns:
+        Union[Dict[str, Any], str]: The parsed JSON dict if valid/repairable,
+        otherwise returns the original string
+    """
+    if not isinstance(json_str, str):
+        return json_str
+    try:
+        # If invalid, attempt repair
+        repaired = repair_json(json_str)
+        return json.loads(repaired)
+    except (json.JSONDecodeError, ImportError):
+        # Return original if repair fails or module not found
+        return json_str
+
+
+class Result(BaseModel):
+    result: Any
+    session_id: str
+
+
+async def run_graph_internal(
+    graph: Graph,
+    flow_id: str,
+    *,
+    stream: bool = False,
+    session_id: str | None = None,
+    inputs: list[InputValueRequest] | None = None,
+    outputs: list[str] | None = None,
+    event_manager: EventManager | None = None,
+) -> tuple[list[RunOutputs], str]:
+    """Run the graph and generate the result."""
+    inputs = inputs or []
+    effective_session_id = session_id or flow_id
+    components = []
+    inputs_list = []
+    types = []
+    for input_value_request in inputs:
+        if input_value_request.input_value is None:
+            logger.warning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
+            input_value_request.input_value = ""
+        components.append(input_value_request.components or [])
+        inputs_list.append({INPUT_FIELD_NAME: input_value_request.input_value})
+        types.append(input_value_request.type)
+
+    try:
+        fallback_to_env_vars = get_settings_service().settings.fallback_to_env_var
+    except (AttributeError, TypeError):
+        fallback_to_env_vars = False
+
+    graph.session_id = effective_session_id
+    run_outputs = await graph.arun(
+        inputs=inputs_list,
+        inputs_components=components,
+        types=types,
+        outputs=outputs or [],
+        stream=stream,
+        session_id=effective_session_id or "",
+        fallback_to_env_vars=fallback_to_env_vars,
+        event_manager=event_manager,
+    )
+    return run_outputs, effective_session_id
+
+
+async def run_graph(
+    graph: Graph,
+    input_value: str,
+    input_type: str,
+    output_type: str,
+    *,
+    session_id: str | None = None,
+    fallback_to_env_vars: bool = False,
+    output_component: str | None = None,
+    stream: bool = False,
+) -> list[RunOutputs]:
+    """Runs the given Langflow Graph with the specified input and returns the outputs.
+
+    Args:
+        graph (Graph): The graph to be executed.
+        input_value (str): The input value to be passed to the graph.
+        input_type (str): The type of the input value.
+        output_type (str): The type of the desired output.
+        session_id (str | None, optional): The session ID to be used for the flow. Defaults to None.
+        fallback_to_env_vars (bool, optional): Whether to fallback to environment variables.
+            Defaults to False.
+        output_component (Optional[str], optional): The specific output component to retrieve. Defaults to None.
+        stream (bool, optional): Whether to stream the results or not. Defaults to False.
+
+    Returns:
+        List[RunOutputs]: A list of RunOutputs objects representing the outputs of the graph.
+
+    """
+    inputs = [InputValue(components=[], input_value=input_value, type=input_type)]
+    if output_component:
+        outputs = [output_component]
+    else:
+        outputs = [
+            vertex.id
+            for vertex in graph.vertices
+            if output_type == "debug"
+            or (vertex.is_output and (output_type == "any" or output_type in vertex.id.lower()))
+        ]
+    components = []
+    inputs_list = []
+    types = []
+    for input_value_request in inputs:
+        if input_value_request.input_value is None:
+            logger.warning("InputValueRequest input_value cannot be None, defaulting to an empty string.")
+            input_value_request.input_value = ""
+        components.append(input_value_request.components or [])
+        inputs_list.append({INPUT_FIELD_NAME: input_value_request.input_value})
+        types.append(input_value_request.type)
+    return await graph.arun(
+        inputs_list,
+        inputs_components=components,
+        types=types,
+        outputs=outputs or [],
+        stream=stream,
+        session_id=session_id,
+        fallback_to_env_vars=fallback_to_env_vars,
+    )
+
+
+def validate_input(
+    graph_data: dict[str, Any], tweaks: Tweaks | dict[str, str | dict[str, Any]]
+) -> list[dict[str, Any]]:
+    if not isinstance(graph_data, dict) or not isinstance(tweaks, dict):
+        msg = "graph_data and tweaks should be dictionaries"
+        raise TypeError(msg)
+
+    nodes = graph_data.get("data", {}).get("nodes") or graph_data.get("nodes")
+
+    if not isinstance(nodes, list):
+        msg = "graph_data should contain a list of nodes under 'data' key or directly under 'nodes' key"
+        raise TypeError(msg)
+
+    return nodes
+
+
+def apply_tweaks(node: dict[str, Any], node_tweaks: dict[str, Any]) -> None:
+    template_data = node.get("data", {}).get("node", {}).get("template")
+
+    if not isinstance(template_data, dict):
+        logger.warning(f"Template data for node {node.get('id')} should be a dictionary")
+        return
+
+    for tweak_name, tweak_value in node_tweaks.items():
+        if tweak_name not in template_data:
+            continue
+        if tweak_name in template_data:
+            if template_data[tweak_name]["type"] == "NestedDict":
+                value = validate_and_repair_json(tweak_value)
+                template_data[tweak_name]["value"] = value
+            elif isinstance(tweak_value, dict):
+                for k, v in tweak_value.items():
+                    k_ = "file_path" if template_data[tweak_name]["type"] == "file" else k
+                    template_data[tweak_name][k_] = v
+            else:
+                key = "file_path" if template_data[tweak_name]["type"] == "file" else "value"
+                template_data[tweak_name][key] = tweak_value
+
+
+def apply_tweaks_on_vertex(vertex: Vertex, node_tweaks: dict[str, Any]) -> None:
+    for tweak_name, tweak_value in node_tweaks.items():
+        if tweak_name and tweak_value and tweak_name in vertex.params:
+            vertex.params[tweak_name] = tweak_value
+
+
+def process_tweaks(
+    graph_data: dict[str, Any], tweaks: Tweaks | dict[str, dict[str, Any]], *, stream: bool = False
+) -> dict[str, Any]:
+    """This function is used to tweak the graph data using the node id and the tweaks dict.
+
+    :param graph_data: The dictionary containing the graph data. It must contain a 'data' key with
+                       'nodes' as its child or directly contain 'nodes' key. Each node should have an 'id' and 'data'.
+    :param tweaks: The dictionary containing the tweaks. The keys can be the node id or the name of the tweak.
+                   The values can be a dictionary containing the tweaks for the node or the value of the tweak.
+    :param stream: A boolean flag indicating whether streaming should be deactivated across all components or not.
+                   Default is False.
+    :return: The modified graph_data dictionary.
+    :raises ValueError: If the input is not in the expected format.
+    """
+    tweaks_dict = cast("dict[str, Any]", tweaks.model_dump()) if not isinstance(tweaks, dict) else tweaks
+    if "stream" not in tweaks_dict:
+        tweaks_dict |= {"stream": stream}
+    nodes = validate_input(graph_data, cast("dict[str, str | dict[str, Any]]", tweaks_dict))
+    nodes_map = {node.get("id"): node for node in nodes}
+    nodes_display_name_map = {node.get("data", {}).get("node", {}).get("display_name"): node for node in nodes}
+
+    all_nodes_tweaks = {}
+    for key, value in tweaks_dict.items():
+        if isinstance(value, dict):
+            if (node := nodes_map.get(key)) or (node := nodes_display_name_map.get(key)):
+                apply_tweaks(node, value)
+        else:
+            all_nodes_tweaks[key] = value
+    if all_nodes_tweaks:
+        for node in nodes:
+            apply_tweaks(node, all_nodes_tweaks)
+
+    return graph_data
+
+
+def process_tweaks_on_graph(graph: Graph, tweaks: dict[str, dict[str, Any]]):
+    for vertex in graph.vertices:
+        if isinstance(vertex, Vertex) and isinstance(vertex.id, str):
+            node_id = vertex.id
+            if node_tweaks := tweaks.get(node_id):
+                apply_tweaks_on_vertex(vertex, node_tweaks)
+        else:
+            logger.warning("Each node should be a Vertex with an 'id' attribute of type str")
+
+    return graph

lfx/processing/utils.py

@@ -0,0 +1,25 @@
+import json
+from typing import Any
+
+from json_repair import repair_json
+
+
+def validate_and_repair_json(json_str: str | dict) -> dict[str, Any] | str:
+    """Validates a JSON string and attempts to repair it if invalid.
+
+    Args:
+        json_str (str): The JSON string to validate/repair
+
+    Returns:
+        Union[Dict[str, Any], str]: The parsed JSON dict if valid/repairable,
+        otherwise returns the original string
+    """
+    if not isinstance(json_str, str):
+        return json_str
+    try:
+        # If invalid, attempt repair
+        repaired = repair_json(json_str)
+        return json.loads(repaired)
+    except (json.JSONDecodeError, ImportError):
+        # Return original if repair fails or module not found
+        return json_str

lfx/schema/__init__.py

@@ -0,0 +1,66 @@
+"""Schema modules for lfx package."""
+
+__all__ = [
+    "Data",
+    "DataFrame",
+    "InputValue",
+    "Message",
+    "OpenAIErrorResponse",
+    "OpenAIResponsesRequest",
+    "OpenAIResponsesResponse",
+    "OpenAIResponsesStreamChunk",
+    "Tweaks",
+    "UUIDstr",
+    "dotdict",
+]
+
+
+def __getattr__(name: str):
+    # Import to avoid circular dependencies
+    if name == "Data":
+        from .data import Data
+
+        return Data
+    if name == "DataFrame":
+        from .dataframe import DataFrame
+
+        return DataFrame
+    if name == "dotdict":
+        from .dotdict import dotdict
+
+        return dotdict
+    if name == "InputValue":
+        from .graph import InputValue
+
+        return InputValue
+    if name == "Tweaks":
+        from .graph import Tweaks
+
+        return Tweaks
+    if name == "Message":
+        from .message import Message
+
+        return Message
+    if name == "UUIDstr":
+        from .serialize import UUIDstr
+
+        return UUIDstr
+    if name == "OpenAIResponsesRequest":
+        from .openai_responses_schemas import OpenAIResponsesRequest
+
+        return OpenAIResponsesRequest
+    if name == "OpenAIResponsesResponse":
+        from .openai_responses_schemas import OpenAIResponsesResponse
+
+        return OpenAIResponsesResponse
+    if name == "OpenAIResponsesStreamChunk":
+        from .openai_responses_schemas import OpenAIResponsesStreamChunk
+
+        return OpenAIResponsesStreamChunk
+    if name == "OpenAIErrorResponse":
+        from .openai_responses_schemas import OpenAIErrorResponse
+
+        return OpenAIErrorResponse
+
+    msg = f"module '{__name__}' has no attribute '{name}'"
+    raise AttributeError(msg)

lfx/schema/artifact.py

@@ -0,0 +1,83 @@
+from collections.abc import Generator
+from enum import Enum
+
+from fastapi.encoders import jsonable_encoder
+from pydantic import BaseModel
+
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.encoders import CUSTOM_ENCODERS
+from lfx.schema.message import Message
+from lfx.serialization.serialization import serialize
+
+
+class ArtifactType(str, Enum):
+    TEXT = "text"
+    DATA = "data"
+    OBJECT = "object"
+    ARRAY = "array"
+    STREAM = "stream"
+    UNKNOWN = "unknown"
+    MESSAGE = "message"
+    RECORD = "record"
+
+
+def get_artifact_type(value, build_result=None) -> str:
+    result = ArtifactType.UNKNOWN
+    match value:
+        case Message():
+            if not isinstance(value.text, str):
+                enum_value = get_artifact_type(value.text)
+                result = ArtifactType(enum_value)
+            else:
+                result = ArtifactType.MESSAGE
+        case Data():
+            enum_value = get_artifact_type(value.data)
+            result = ArtifactType(enum_value)
+
+        case str():
+            result = ArtifactType.TEXT
+
+        case dict():
+            result = ArtifactType.OBJECT
+
+        case list() | DataFrame():
+            result = ArtifactType.ARRAY
+    if result == ArtifactType.UNKNOWN and (
+        (build_result and isinstance(build_result, Generator))
+        or (isinstance(value, Message) and isinstance(value.text, Generator))
+    ):
+        result = ArtifactType.STREAM
+
+    return result.value
+
+
+def _to_list_of_dicts(raw):
+    raw_ = []
+    for item in raw:
+        if hasattr(item, "dict") or hasattr(item, "model_dump"):
+            raw_.append(serialize(item))
+        else:
+            raw_.append(str(item))
+    return raw_
+
+
+def post_process_raw(raw, artifact_type: str):
+    default_message = "Built Successfully ✨"
+
+    if artifact_type == ArtifactType.STREAM.value:
+        raw = ""
+    elif artifact_type == ArtifactType.ARRAY.value:
+        raw = raw.to_dict(orient="records") if isinstance(raw, DataFrame) else _to_list_of_dicts(raw)
+    elif artifact_type == ArtifactType.UNKNOWN.value and raw is not None:
+        if isinstance(raw, BaseModel | dict):
+            try:
+                raw = jsonable_encoder(raw, custom_encoder=CUSTOM_ENCODERS)
+                artifact_type = ArtifactType.OBJECT.value
+            except Exception:  # noqa: BLE001
+                logger.debug(f"Error converting to json: {raw} ({type(raw)})", exc_info=True)
+                raw = default_message
+        else:
+            raw = default_message
+    return raw, artifact_type