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

lfx/schema/schema.py

@@ -0,0 +1,171 @@
+from collections.abc import Generator
+from enum import Enum
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    from lfx.custom.custom_component.component import Component
+
+INPUT_FIELD_NAME = "input_value"
+
+InputType = Literal["chat", "text", "any"]
+OutputType = Literal["chat", "text", "any", "debug"]
+
+
+class LogType(str, Enum):
+    MESSAGE = "message"
+    DATA = "data"
+    STREAM = "stream"
+    OBJECT = "object"
+    ARRAY = "array"
+    TEXT = "text"
+    UNKNOWN = "unknown"
+
+
+class StreamURL(TypedDict):
+    location: str
+
+
+class ErrorLog(TypedDict):
+    errorMessage: str
+    stackTrace: str
+
+
+class OutputValue(BaseModel):
+    message: ErrorLog | StreamURL | dict | list | str
+    type: str
+
+
+def get_type(payload):
+    # Importing here to avoid circular imports
+    from lfx.schema.data import Data
+    from lfx.schema.dataframe import DataFrame
+    from lfx.schema.message import Message
+
+    result = LogType.UNKNOWN
+    match payload:
+        case Message():
+            result = LogType.MESSAGE
+
+        case Data():
+            result = LogType.DATA
+
+        case dict():
+            result = LogType.OBJECT
+
+        case list() | DataFrame():
+            result = LogType.ARRAY
+
+        case str():
+            result = LogType.TEXT
+
+    if result == LogType.UNKNOWN and (
+        (payload and isinstance(payload, Generator))
+        or (isinstance(payload, Message) and isinstance(payload.text, Generator))
+    ):
+        result = LogType.STREAM
+
+    return result
+
+
+def get_message(payload):
+    # Importing here to avoid circular imports
+    from lfx.schema.data import Data
+
+    message = None
+    if hasattr(payload, "data"):
+        message = payload.data
+
+    elif hasattr(payload, "model_dump"):
+        message = payload.model_dump()
+
+    if message is None and isinstance(payload, dict | str | Data):
+        message = payload.data if isinstance(payload, Data) else payload
+
+    return message or payload
+
+
+def build_output_logs(vertex, result) -> dict:
+    """Build output logs from vertex outputs and results."""
+    # Importing here to avoid circular imports
+    from lfx.schema.dataframe import DataFrame
+    from lfx.serialization.serialization import serialize
+
+    outputs: dict[str, OutputValue] = {}
+    component_instance: Component = result[0]
+    for index, output in enumerate(vertex.outputs):
+        if component_instance.status is None:
+            payload = component_instance.get_results()
+            output_result = payload.get(output["name"])
+        else:
+            payload = component_instance.get_artifacts()
+            output_result = payload.get(output["name"], {}).get("raw")
+        message = get_message(output_result)
+        type_ = get_type(output_result)
+
+        match type_:
+            case LogType.STREAM if "stream_url" in message:
+                message = StreamURL(location=message["stream_url"])
+
+            case LogType.STREAM:
+                message = ""
+
+            case LogType.MESSAGE if hasattr(message, "message"):
+                message = message.message
+
+            case LogType.UNKNOWN:
+                message = ""
+
+            case LogType.ARRAY:
+                if isinstance(message, DataFrame):
+                    message = message.to_dict(orient="records")
+                message = [serialize(item) for item in message]
+        name = output.get("name", f"output_{index}")
+        outputs |= {name: OutputValue(message=message, type=type_).model_dump()}
+
+    return outputs
+
+
+class BuildStatus(BaseModel):
+    """Build status schema for API compatibility."""
+
+    status: str
+    message: str | None = None
+    progress: float | None = None
+
+
+class InputValueRequest(BaseModel):
+    components: list[str] | None = []
+    input_value: str | None = None
+    session: str | None = None
+    type: InputType | None = Field(
+        "any",
+        description="Defines on which components the input value should be applied. "
+        "'any' applies to all input components.",
+    )
+
+    # add an example
+    model_config = ConfigDict(
+        json_schema_extra={
+            "examples": [
+                {
+                    "components": ["components_id", "Component Name"],
+                    "input_value": "input_value",
+                    "session": "session_id",
+                },
+                {"components": ["Component Name"], "input_value": "input_value"},
+                {"input_value": "input_value"},
+                {
+                    "components": ["Component Name"],
+                    "input_value": "input_value",
+                    "session": "session_id",
+                },
+                {"input_value": "input_value", "session": "session_id"},
+                {"type": "chat", "input_value": "input_value"},
+                {"type": "json", "input_value": '{"key": "value"}'},
+            ]
+        },
+        extra="forbid",
+    )

lfx/schema/serialize.py

@@ -0,0 +1,13 @@
+from typing import Annotated
+from uuid import UUID
+
+from pydantic import BeforeValidator
+
+
+def str_to_uuid(v: str | UUID) -> UUID:
+    if isinstance(v, str):
+        return UUID(v)
+    return v
+
+
+UUIDstr = Annotated[UUID, BeforeValidator(str_to_uuid)]

lfx/schema/table.py

@@ -0,0 +1,140 @@
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+VALID_TYPES = [
+    "date",
+    "number",
+    "text",
+    "json",
+    "integer",
+    "int",
+    "float",
+    "str",
+    "string",
+    "boolean",
+]
+
+
+class FormatterType(str, Enum):
+    date = "date"
+    text = "text"
+    number = "number"
+    json = "json"
+    boolean = "boolean"
+
+
+class EditMode(str, Enum):
+    MODAL = "modal"
+    POPOVER = "popover"
+    INLINE = "inline"
+
+
+class Column(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    name: str
+    display_name: str = Field(default="")
+    options: list[str] | None = Field(default=None)
+    sortable: bool = Field(default=True)
+    filterable: bool = Field(default=True)
+    formatter: FormatterType | str | None = Field(default=None)
+    type: FormatterType | str | None = Field(default=None)
+    description: str | None = None
+    default: str | bool | int | float | None = None
+    disable_edit: bool = Field(default=False)
+    edit_mode: EditMode | None = Field(default=EditMode.POPOVER)
+    hidden: bool = Field(default=False)
+
+    @model_validator(mode="after")
+    def set_display_name(self):
+        if not self.display_name:
+            self.display_name = self.name
+        return self
+
+    @model_validator(mode="after")
+    def set_formatter_from_type(self):
+        if self.type and not self.formatter:
+            self.formatter = self.validate_formatter(self.type)
+        if self.formatter in {"boolean", "bool"}:
+            valid_trues = ["True", "true", "1", "yes"]
+            valid_falses = ["False", "false", "0", "no"]
+            if self.default in valid_trues:
+                self.default = True
+            if self.default in valid_falses:
+                self.default = False
+        elif self.formatter in {"integer", "int"}:
+            self.default = int(self.default)
+        elif self.formatter in {"float"}:
+            self.default = float(self.default)
+        else:
+            self.default = str(self.default)
+        return self
+
+    @field_validator("formatter", mode="before")
+    @classmethod
+    def validate_formatter(cls, value):
+        if value in {"boolean", "bool"}:
+            value = FormatterType.boolean
+        if value in {"integer", "int", "float"}:
+            value = FormatterType.number
+        if value in {"str", "string"}:
+            value = FormatterType.text
+        if value == "dict":
+            value = FormatterType.json
+        if value == "date":
+            value = FormatterType.date
+        if isinstance(value, str):
+            return FormatterType(value)
+        if isinstance(value, FormatterType):
+            return value
+        msg = f"Invalid formatter type: {value}. Valid types are: {FormatterType}"
+        raise ValueError(msg)
+
+
+class TableSchema(BaseModel):
+    columns: list[Column]
+
+
+class FieldValidatorType(str, Enum):
+    """Enum for field validation types."""
+
+    NO_SPACES = "no_spaces"  # Prevents spaces in input
+    LOWERCASE = "lowercase"  # Forces lowercase
+    UPPERCASE = "uppercase"  # Forces uppercase
+    EMAIL = "email"  # Validates email format
+    URL = "url"  # Validates URL format
+    ALPHANUMERIC = "alphanumeric"  # Only letters and numbers
+    NUMERIC = "numeric"  # Only numbers
+    ALPHA = "alpha"  # Only letters
+    PHONE = "phone"  # Phone number format
+    SLUG = "slug"  # URL slug format (lowercase, hyphens)
+    USERNAME = "username"  # Alphanumeric with underscores
+    PASSWORD = "password"  # Minimum security requirements
+
+
+class FieldParserType(str, Enum):
+    """Enum for field parser types."""
+
+    SNAKE_CASE = "snake_case"
+    CAMEL_CASE = "camel_case"
+    PASCAL_CASE = "pascal_case"
+    KEBAB_CASE = "kebab_case"
+    LOWERCASE = "lowercase"
+    UPPERCASE = "uppercase"
+    NO_BLANK = "no_blank"
+    VALID_CSV = ("valid_csv",)
+    COMMANDS = "commands"
+
+
+class TableOptions(BaseModel):
+    block_add: bool = Field(default=False)
+    block_delete: bool = Field(default=False)
+    block_edit: bool = Field(default=False)
+    block_sort: bool = Field(default=False)
+    block_filter: bool = Field(default=False)
+    block_hide: bool | list[str] = Field(default=False)
+    block_select: bool = Field(default=False)
+    hide_options: bool = Field(default=False)
+    field_validators: dict[str, list[FieldValidatorType] | FieldValidatorType] | None = Field(default=None)
+    field_parsers: dict[str, list[FieldParserType] | FieldParserType] | None = Field(default=None)
+    description: str | None = Field(default=None)

lfx/schema/validators.py

@@ -0,0 +1,114 @@
+from datetime import datetime, timezone
+
+from pydantic import BeforeValidator
+
+
+def timestamp_to_str(timestamp: datetime | str) -> str:
+    """Convert timestamp to standardized string format.
+
+    Handles multiple input formats and ensures consistent UTC timezone output.
+
+    Args:
+        timestamp (datetime | str): Input timestamp either as datetime object or string
+
+    Returns:
+        str: Formatted timestamp string in 'YYYY-MM-DD HH:MM:SS UTC' format
+
+    Raises:
+        ValueError: If string timestamp is in invalid format
+    """
+    if isinstance(timestamp, str):
+        # Try parsing with different formats
+        formats = [
+            "%Y-%m-%dT%H:%M:%S",  # ISO format
+            "%Y-%m-%d %H:%M:%S %Z",  # Standard with timezone
+            "%Y-%m-%d %H:%M:%S",  # Without timezone
+            "%Y-%m-%dT%H:%M:%S.%f",  # ISO with microseconds
+            "%Y-%m-%dT%H:%M:%S%z",  # ISO with numeric timezone
+        ]
+
+        for fmt in formats:
+            try:
+                parsed = datetime.strptime(timestamp.strip(), fmt).replace(tzinfo=timezone.utc)
+                return parsed.strftime("%Y-%m-%d %H:%M:%S %Z")
+            except ValueError:
+                continue
+
+        msg = f"Invalid timestamp format: {timestamp}"
+        raise ValueError(msg)
+
+    # Handle datetime object
+    if timestamp.tzinfo is None:
+        timestamp = timestamp.replace(tzinfo=timezone.utc)
+    return timestamp.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def str_to_timestamp(timestamp: str | datetime) -> datetime:
+    """Convert timestamp to datetime object.
+
+    Handles multiple input formats and ensures consistent UTC timezone output.
+
+    Args:
+        timestamp (str | datetime): Input timestamp either as string or datetime object
+
+    Returns:
+        datetime: Datetime object with UTC timezone
+
+    Raises:
+        ValueError: If string timestamp is not in 'YYYY-MM-DD HH:MM:SS UTC' format
+    """
+    if isinstance(timestamp, str):
+        try:
+            return datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S %Z").replace(tzinfo=timezone.utc)
+        except ValueError as e:
+            msg = f"Invalid timestamp format: {timestamp}. Expected format: YYYY-MM-DD HH:MM:SS UTC"
+            raise ValueError(msg) from e
+    return timestamp
+
+
+def timestamp_with_fractional_seconds(timestamp: datetime | str) -> str:
+    """Convert timestamp to string format including fractional seconds.
+
+    Handles multiple input formats and ensures consistent UTC timezone output.
+
+    Args:
+        timestamp (datetime | str): Input timestamp either as datetime object or string
+
+    Returns:
+        str: Formatted timestamp string in 'YYYY-MM-DD HH:MM:SS.ffffff UTC' format
+
+    Raises:
+        ValueError: If string timestamp is in invalid format
+    """
+    if isinstance(timestamp, str):
+        # Try parsing with different formats
+        formats = [
+            "%Y-%m-%d %H:%M:%S.%f %Z",  # Standard with timezone
+            "%Y-%m-%d %H:%M:%S.%f",  # Without timezone
+            "%Y-%m-%dT%H:%M:%S.%f",  # ISO format
+            "%Y-%m-%dT%H:%M:%S.%f%z",  # ISO with numeric timezone
+            # Also try without fractional seconds
+            "%Y-%m-%d %H:%M:%S %Z",
+            "%Y-%m-%d %H:%M:%S",
+            "%Y-%m-%dT%H:%M:%S",
+        ]
+
+        for fmt in formats:
+            try:
+                parsed = datetime.strptime(timestamp.strip(), fmt).replace(tzinfo=timezone.utc)
+                return parsed.strftime("%Y-%m-%d %H:%M:%S.%f %Z")
+            except ValueError:
+                continue
+
+        msg = f"Invalid timestamp format: {timestamp}"
+        raise ValueError(msg)
+
+    # Handle datetime object
+    if timestamp.tzinfo is None:
+        timestamp = timestamp.replace(tzinfo=timezone.utc)
+    return timestamp.strftime("%Y-%m-%d %H:%M:%S.%f %Z")
+
+
+timestamp_to_str_validator = BeforeValidator(timestamp_to_str)
+timestamp_with_fractional_seconds_validator = BeforeValidator(timestamp_with_fractional_seconds)
+str_to_timestamp_validator = BeforeValidator(str_to_timestamp)

lfx/serialization/__init__.py

@@ -0,0 +1,5 @@
+"""Serialization module for lfx package."""
+
+from .serialization import serialize, serialize_or_str
+
+__all__ = ["serialize", "serialize_or_str"]

lfx/serialization/constants.py

@@ -0,0 +1,2 @@
+MAX_TEXT_LENGTH = 6000
+MAX_ITEMS_LENGTH = 1000