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

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

lfx/schema/content_block.py

@@ -0,0 +1,62 @@
+from typing import Annotated
+
+from pydantic import BaseModel, Discriminator, Field, Tag, field_serializer, field_validator
+from typing_extensions import TypedDict
+
+from .content_types import CodeContent, ErrorContent, JSONContent, MediaContent, TextContent, ToolContent
+
+
+def _get_type(d: dict | BaseModel) -> str | None:
+    if isinstance(d, dict):
+        return d.get("type")
+    return getattr(d, "type", None)
+
+
+# Create a union type of all content types
+ContentType = Annotated[
+    Annotated[ToolContent, Tag("tool_use")]
+    | Annotated[ErrorContent, Tag("error")]
+    | Annotated[TextContent, Tag("text")]
+    | Annotated[MediaContent, Tag("media")]
+    | Annotated[CodeContent, Tag("code")]
+    | Annotated[JSONContent, Tag("json")],
+    Discriminator(_get_type),
+]
+
+
+class ContentBlock(BaseModel):
+    """A block of content that can contain different types of content."""
+
+    title: str
+    contents: list[ContentType]
+    allow_markdown: bool = Field(default=True)
+    media_url: list[str] | None = None
+
+    def __init__(self, **data) -> None:
+        super().__init__(**data)
+        schema_dict = self.__pydantic_core_schema__["schema"]
+        if "fields" in schema_dict:
+            fields = schema_dict["fields"]
+        elif "schema" in schema_dict:
+            fields = schema_dict["schema"]["fields"]
+        fields_with_default = (f for f, d in fields.items() if "default" in d["schema"])
+        self.model_fields_set.update(fields_with_default)
+
+    @field_validator("contents", mode="before")
+    @classmethod
+    def validate_contents(cls, v) -> list[ContentType]:
+        if isinstance(v, dict):
+            msg = "Contents must be a list of ContentTypes"
+            raise TypeError(msg)
+        return [v] if isinstance(v, BaseModel) else v
+
+    @field_serializer("contents")
+    def serialize_contents(self, value) -> list[dict]:
+        return [v.model_dump() for v in value]
+
+
+class ContentBlockDict(TypedDict):
+    title: str
+    contents: list[dict]
+    allow_markdown: bool
+    media_url: list[str] | None

lfx/schema/content_types.py

@@ -0,0 +1,91 @@
+from typing import Any, Literal
+
+from fastapi.encoders import jsonable_encoder
+from pydantic import BaseModel, ConfigDict, Field, model_serializer
+from typing_extensions import TypedDict
+
+from lfx.schema.encoders import CUSTOM_ENCODERS
+
+
+class HeaderDict(TypedDict, total=False):
+    title: str | None
+    icon: str | None
+
+
+class BaseContent(BaseModel):
+    """Base class for all content types."""
+
+    type: str = Field(..., description="Type of the content")
+    duration: int | None = None
+    header: HeaderDict | None = Field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "BaseContent":
+        return cls(**data)
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, nxt) -> dict[str, Any]:
+        try:
+            dump = nxt(self)
+            return jsonable_encoder(dump, custom_encoder=CUSTOM_ENCODERS)
+        except Exception:  # noqa: BLE001
+            return nxt(self)
+
+
+class ErrorContent(BaseContent):
+    """Content type for error messages."""
+
+    type: Literal["error"] = Field(default="error")
+    component: str | None = None
+    field: str | None = None
+    reason: str | None = None
+    solution: str | None = None
+    traceback: str | None = None
+
+
+class TextContent(BaseContent):
+    """Content type for simple text content."""
+
+    type: Literal["text"] = Field(default="text")
+    text: str
+    duration: int | None = None
+
+
+class MediaContent(BaseContent):
+    """Content type for media content."""
+
+    type: Literal["media"] = Field(default="media")
+    urls: list[str]
+    caption: str | None = None
+
+
+class JSONContent(BaseContent):
+    """Content type for JSON content."""
+
+    type: Literal["json"] = Field(default="json")
+    data: dict[str, Any]
+
+
+class CodeContent(BaseContent):
+    """Content type for code snippets."""
+
+    type: Literal["code"] = Field(default="code")
+    code: str
+    language: str
+    title: str | None = None
+
+
+class ToolContent(BaseContent):
+    """Content type for tool start content."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    type: Literal["tool_use"] = Field(default="tool_use")
+    name: str | None = None
+    tool_input: dict[str, Any] = Field(default_factory=dict, alias="input")
+    output: Any | None = None
+    error: Any | None = None
+    duration: int | None = None

lfx/schema/cross_module.py

@@ -0,0 +1,80 @@
+"""Cross-module BaseModel for handling re-exported classes.
+
+This module provides a metaclass and base model that enable isinstance checks
+to work across module boundaries for Pydantic models. This is particularly useful
+when the same class is re-exported from different modules (e.g., lfx.Message vs
+langflow.schema.Message) but Python's isinstance() checks fail due to different
+module paths.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class CrossModuleMeta(type(BaseModel)):  # type: ignore[misc]
+    """Metaclass that enables cross-module isinstance checks for Pydantic models.
+
+    This metaclass overrides __instancecheck__ to perform structural type checking
+    based on the model's fields rather than strict class identity. This allows
+    instances of the same model from different module paths to be recognized as
+    compatible.
+    """
+
+    def __instancecheck__(cls, instance: Any) -> bool:
+        """Check if instance is compatible with this class across module boundaries.
+
+        First performs a standard isinstance check. If that fails, falls back to
+        checking if the instance has all required Pydantic model attributes and
+        a compatible set of model fields.
+
+        Args:
+            instance: The object to check.
+
+        Returns:
+            bool: True if instance is compatible with this class.
+        """
+        # First try standard isinstance check
+        if type.__instancecheck__(cls, instance):
+            return True
+
+        # If that fails, check for cross-module compatibility
+        # An object is cross-module compatible if it:
+        # 1. Has model_fields attribute (is a Pydantic model)
+        # 2. Has the same __class__.__name__
+        # 3. Has compatible model fields
+        if not hasattr(instance, "model_fields"):
+            return False
+
+        # Check if class names match
+        if instance.__class__.__name__ != cls.__name__:
+            return False
+
+        # Check if the instance has all required fields from cls
+        cls_fields = set(cls.model_fields.keys()) if hasattr(cls, "model_fields") else set()
+        instance_fields = set(instance.model_fields.keys())
+
+        # The instance must have at least the same fields as the class
+        # (it can have more, but not fewer required fields)
+        return cls_fields.issubset(instance_fields)
+
+
+class CrossModuleModel(BaseModel, metaclass=CrossModuleMeta):
+    """Base Pydantic model with cross-module isinstance support.
+
+    This class should be used as the base for models that may be re-exported
+    from different modules. It enables isinstance() checks to work across
+    module boundaries by using structural type checking.
+
+    Example:
+        >>> class Message(CrossModuleModel):
+        ...     text: str
+        ...
+        >>> # Even if Message is imported from different paths:
+        >>> from lfx.schema.message import Message as LfxMessage
+        >>> from langflow.schema import Message as LangflowMessage
+        >>> msg = LfxMessage(text="hello")
+        >>> isinstance(msg, LangflowMessage)  # True (with cross-module support)
+    """

lfx/schema/data.py

@@ -0,0 +1,309 @@
+"""Lightweight Data class for lfx package - contains only methods with no langflow dependencies."""
+
+from __future__ import annotations
+
+import copy
+import json
+from datetime import datetime, timezone
+from decimal import Decimal
+from typing import TYPE_CHECKING, cast
+from uuid import UUID
+
+from langchain_core.documents import Document
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+from pydantic import BaseModel, ConfigDict, model_serializer, model_validator
+
+from lfx.log.logger import logger
+from lfx.schema.cross_module import CrossModuleModel
+from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
+from lfx.utils.image import create_image_content_dict
+
+if TYPE_CHECKING:
+    from lfx.schema.dataframe import DataFrame
+    from lfx.schema.message import Message
+
+
+class Data(CrossModuleModel):
+    """Represents a record with text and optional data.
+
+    Attributes:
+        data (dict, optional): Additional data associated with the record.
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    text_key: str = "text"
+    data: dict = {}
+    default_value: str | None = ""
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_data(cls, values):
+        if not isinstance(values, dict):
+            msg = "Data must be a dictionary"
+            raise ValueError(msg)  # noqa: TRY004
+        if "data" not in values or values["data"] is None:
+            values["data"] = {}
+        if not isinstance(values["data"], dict):
+            msg = (
+                f"Invalid data format: expected dictionary but got {type(values).__name__}."
+                " This will raise an error in version langflow==1.3.0."
+            )
+            logger.warning(msg)
+        # Any other keyword should be added to the data dictionary
+        for key in values:
+            if key not in values["data"] and key not in {"text_key", "data", "default_value"}:
+                values["data"][key] = values[key]
+        return values
+
+    @model_serializer(mode="plain", when_used="json")
+    def serialize_model(self):
+        return {k: v.to_json() if hasattr(v, "to_json") else v for k, v in self.data.items()}
+
+    def get_text(self):
+        """Retrieves the text value from the data dictionary.
+
+        If the text key is present in the data dictionary, the corresponding value is returned.
+        Otherwise, the default value is returned.
+
+        Returns:
+            The text value from the data dictionary or the default value.
+        """
+        return self.data.get(self.text_key, self.default_value)
+
+    def set_text(self, text: str | None) -> str:
+        r"""Sets the text value in the data dictionary.
+
+        The object's `text` value is set to `text parameter as given, with the following modifications:
+
+         - `text` value of `None` is converted to an empty string.
+         - `text` value is converted to `str` type.
+
+        Args:
+            text (str): The text to be set in the data dictionary.
+
+        Returns:
+            str: The text value that was set in the data dictionary.
+        """
+        new_text = "" if text is None else str(text)
+        self.data[self.text_key] = new_text
+        return new_text
+
+    @classmethod
+    def from_document(cls, document: Document) -> Data:
+        """Converts a Document to a Data.
+
+        Args:
+            document (Document): The Document to convert.
+
+        Returns:
+            Data: The converted Data.
+        """
+        data = document.metadata
+        data["text"] = document.page_content
+        return cls(data=data, text_key="text")
+
+    @classmethod
+    def from_lc_message(cls, message: BaseMessage) -> Data:
+        """Converts a BaseMessage to a Data.
+
+        Args:
+            message (BaseMessage): The BaseMessage to convert.
+
+        Returns:
+            Data: The converted Data.
+        """
+        data: dict = {"text": message.content}
+        data["metadata"] = cast("dict", message.to_json())
+        return cls(data=data, text_key="text")
+
+    def __add__(self, other: Data) -> Data:
+        """Combines the data of two data by attempting to add values for overlapping keys.
+
+        Combines the data of two data by attempting to add values for overlapping keys
+        for all types that support the addition operation. Falls back to the value from 'other'
+        record when addition is not supported.
+        """
+        combined_data = self.data.copy()
+        for key, value in other.data.items():
+            # If the key exists in both data and both values support the addition operation
+            if key in combined_data:
+                try:
+                    combined_data[key] += value
+                except TypeError:
+                    # Fallback: Use the value from 'other' record if addition is not supported
+                    combined_data[key] = value
+            else:
+                # If the key is not in the first record, simply add it
+                combined_data[key] = value
+
+        return Data(data=combined_data)
+
+    def to_lc_document(self) -> Document:
+        """Converts the Data to a Document.
+
+        Returns:
+            Document: The converted Document.
+        """
+        data_copy = self.data.copy()
+        text = data_copy.pop(self.text_key, self.default_value)
+        if isinstance(text, str):
+            return Document(page_content=text, metadata=data_copy)
+        return Document(page_content=str(text), metadata=data_copy)
+
+    def to_lc_message(
+        self,
+    ) -> BaseMessage:
+        """Converts the Data to a BaseMessage.
+
+        Returns:
+            BaseMessage: The converted BaseMessage.
+        """
+        # The idea of this function is to be a helper to convert a Data to a BaseMessage
+        # It will use the "sender" key to determine if the message is Human or AI
+        # If the key is not present, it will default to AI
+        # But first we check if all required keys are present in the data dictionary
+        # they are: "text", "sender"
+        if not all(key in self.data for key in ["text", "sender"]):
+            msg = f"Missing required keys ('text', 'sender') in Data: {self.data}"
+            raise ValueError(msg)
+        sender = self.data.get("sender", MESSAGE_SENDER_AI)
+        text = self.data.get("text", "")
+        files = self.data.get("files", [])
+        if sender == MESSAGE_SENDER_USER:
+            if files:
+                from lfx.schema.image import get_file_paths
+
+                resolved_file_paths = get_file_paths(files)
+                contents = [create_image_content_dict(file_path) for file_path in resolved_file_paths]
+                # add to the beginning of the list
+                contents.insert(0, {"type": "text", "text": text})
+                human_message = HumanMessage(content=contents)
+            else:
+                human_message = HumanMessage(
+                    content=[{"type": "text", "text": text}],
+                )
+
+            return human_message
+
+        return AIMessage(content=text)
+
+    def __getattr__(self, key):
+        """Allows attribute-like access to the data dictionary."""
+        try:
+            if key.startswith("__"):
+                return self.__getattribute__(key)
+            if key in {"data", "text_key"} or key.startswith("_"):
+                return super().__getattr__(key)
+            return self.data[key]
+        except KeyError as e:
+            # Fallback to default behavior to raise AttributeError for undefined attributes
+            msg = f"'{type(self).__name__}' object has no attribute '{key}'"
+            raise AttributeError(msg) from e
+
+    def __setattr__(self, key, value) -> None:
+        """Set attribute-like values in the data dictionary.
+
+        Allows attribute-like setting of values in the data dictionary.
+        while still allowing direct assignment to class attributes.
+        """
+        if key in {"data", "text_key"} or key.startswith("_"):
+            super().__setattr__(key, value)
+        elif key in self.model_fields:
+            self.data[key] = value
+            super().__setattr__(key, value)
+        else:
+            self.data[key] = value
+
+    def __delattr__(self, key) -> None:
+        """Allows attribute-like deletion from the data dictionary."""
+        if key in {"data", "text_key"} or key.startswith("_"):
+            super().__delattr__(key)
+        else:
+            del self.data[key]
+
+    def __deepcopy__(self, memo):
+        """Custom deepcopy implementation to handle copying of the Data object."""
+        # Create a new Data object with a deep copy of the data dictionary
+        return Data(data=copy.deepcopy(self.data, memo), text_key=self.text_key, default_value=self.default_value)
+
+    # check which attributes the Data has by checking the keys in the data dictionary
+    def __dir__(self):
+        return super().__dir__() + list(self.data.keys())
+
+    def __str__(self) -> str:
+        # return a JSON string representation of the Data atributes
+        try:
+            data = {k: v.to_json() if hasattr(v, "to_json") else v for k, v in self.data.items()}
+            return serialize_data(data)  # use the custom serializer
+        except Exception:  # noqa: BLE001
+            logger.debug("Error converting Data to JSON", exc_info=True)
+            return str(self.data)
+
+    def __contains__(self, key) -> bool:
+        return key in self.data
+
+    def __eq__(self, /, other):
+        return isinstance(other, Data) and self.data == other.data
+
+    def filter_data(self, filter_str: str) -> Data:
+        """Filters the data dictionary based on the filter string.
+
+        Args:
+            filter_str (str): The filter string to apply to the data dictionary.
+
+        Returns:
+            Data: The filtered Data.
+        """
+        from lfx.template.utils import apply_json_filter
+
+        return apply_json_filter(self.data, filter_str)
+
+    def to_message(self) -> Message:
+        from lfx.schema.message import Message  # Local import to avoid circular import
+
+        if self.text_key in self.data:
+            return Message(text=self.get_text())
+        return Message(text=str(self.data))
+
+    def to_dataframe(self) -> DataFrame:
+        from lfx.schema.dataframe import DataFrame  # Local import to avoid circular import
+
+        data_dict = self.data
+        # If data contains only one key and the value is a list of dictionaries, convert to DataFrame
+        if (
+            len(data_dict) == 1
+            and isinstance(next(iter(data_dict.values())), list)
+            and all(isinstance(item, dict) for item in next(iter(data_dict.values())))
+        ):
+            return DataFrame(data=next(iter(data_dict.values())))
+        return DataFrame(data=[self])
+
+    def __repr__(self) -> str:
+        """Return string representation of the Data object."""
+        return f"Data(text_key={self.text_key!r}, data={self.data!r}, default_value={self.default_value!r})"
+
+    def __hash__(self) -> int:
+        """Return hash of the Data object based on its string representation."""
+        return hash(self.__repr__())
+
+
+def custom_serializer(obj):
+    if isinstance(obj, datetime):
+        utc_date = obj.replace(tzinfo=timezone.utc)
+        return utc_date.strftime("%Y-%m-%d %H:%M:%S %Z")
+    if isinstance(obj, Decimal):
+        return float(obj)
+    if isinstance(obj, UUID):
+        return str(obj)
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    if isinstance(obj, bytes):
+        return obj.decode("utf-8", errors="replace")
+    # Add more custom serialization rules as needed
+    msg = f"Type {type(obj)} not serializable"
+    raise TypeError(msg)
+
+
+def serialize_data(data):
+    return json.dumps(data, indent=4, default=custom_serializer)