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

lfx/schema/dotdict.py

@@ -0,0 +1,74 @@
+"""Dot-notation dictionary implementation copied from langflow for lfx package."""
+
+
+class dotdict(dict):  # noqa: N801
+    """dotdict allows accessing dictionary elements using dot notation (e.g., dict.key instead of dict['key']).
+
+    It automatically converts nested dictionaries into dotdict instances, enabling dot notation on them as well.
+
+    Note:
+        - Only keys that are valid attribute names (e.g., strings that could be variable names) are accessible via dot
+          notation.
+        - Keys which are not valid Python attribute names or collide with the dict method names (like 'items', 'keys')
+          should be accessed using the traditional dict['key'] notation.
+    """
+
+    def __getattr__(self, attr):
+        """Override dot access to behave like dictionary lookup. Automatically convert nested dicts to dotdicts.
+
+        Args:
+            attr (str): Attribute to access.
+
+        Returns:
+            The value associated with 'attr' in the dictionary, converted to dotdict if it is a dict.
+
+        Raises:
+            AttributeError: If the attribute is not found in the dictionary.
+        """
+        try:
+            value = self[attr]
+            if isinstance(value, dict) and not isinstance(value, dotdict):
+                value = dotdict(value)
+                self[attr] = value  # Update self to nest dotdict for future accesses
+        except KeyError as e:
+            msg = f"'dotdict' object has no attribute '{attr}'"
+            raise AttributeError(msg) from e
+        else:
+            return value
+
+    def __setattr__(self, key, value) -> None:
+        """Override attribute setting to work as dictionary item assignment.
+
+        Args:
+            key (str): The key under which to store the value.
+            value: The value to store in the dictionary.
+        """
+        if isinstance(value, dict) and not isinstance(value, dotdict):
+            value = dotdict(value)
+        self[key] = value
+
+    def __delattr__(self, key) -> None:
+        """Override attribute deletion to work as dictionary item deletion.
+
+        Args:
+            key (str): The key of the item to delete from the dictionary.
+
+        Raises:
+            AttributeError: If the key is not found in the dictionary.
+        """
+        try:
+            del self[key]
+        except KeyError as e:
+            msg = f"'dotdict' object has no attribute '{key}'"
+            raise AttributeError(msg) from e
+
+    def __missing__(self, key):
+        """Handle missing keys by returning an empty dotdict. This allows chaining access without raising KeyError.
+
+        Args:
+            key: The missing key.
+
+        Returns:
+            An empty dotdict instance for the given missing key.
+        """
+        return dotdict()

lfx/schema/encoders.py

@@ -0,0 +1,13 @@
+from collections.abc import Callable
+from datetime import datetime
+
+
+def encode_callable(obj: Callable):
+    return obj.__name__ if hasattr(obj, "__name__") else str(obj)
+
+
+def encode_datetime(obj: datetime):
+    return obj.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+CUSTOM_ENCODERS = {Callable: encode_callable, datetime: encode_datetime}

lfx/schema/graph.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+from pydantic import BaseModel, Field, RootModel
+
+from lfx.schema.schema import InputType
+
+
+class InputValue(BaseModel):
+    components: list[str] | None = []
+    input_value: 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.",
+    )
+
+
+class Tweaks(RootModel):
+    root: dict[str, str | dict[str, Any]] = Field(
+        description="A dictionary of tweaks to adjust the flow's execution. "
+        "Allows customizing flow behavior dynamically. "
+        "All tweaks are overridden by the input values.",
+    )
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "parameter_name": "value",
+                    "Component Name": {"parameter_name": "value"},
+                    "component_id": {"parameter_name": "value"},
+                }
+            ]
+        }
+    }
+
+    # This should behave like a dict
+    def __getitem__(self, key):
+        return self.root[key]
+
+    def __setitem__(self, key, value) -> None:
+        self.root[key] = value
+
+    def __delitem__(self, key) -> None:
+        del self.root[key]
+
+    def items(self):
+        return self.root.items()

lfx/schema/image.py

@@ -0,0 +1,131 @@
+import base64
+from pathlib import Path
+
+import aiofiles
+from PIL import Image as PILImage
+from platformdirs import user_cache_dir
+from pydantic import BaseModel
+
+from lfx.services.deps import get_storage_service
+
+IMAGE_ENDPOINT = "/files/images/"
+
+
+def is_image_file(file_path) -> bool:
+    """Check if a file is a valid image."""
+    try:
+        with PILImage.open(file_path) as img:
+            img.verify()  # Verify that it is, in fact, an image
+    except (OSError, SyntaxError):
+        return False
+    return True
+
+
+def get_file_paths(files: list[str | dict]):
+    """Get file paths for a list of files."""
+    storage_service = get_storage_service()
+    if not storage_service:
+        # Extract paths from dicts if present
+
+        extracted_files = []
+        cache_dir = Path(user_cache_dir("langflow"))
+
+        for file in files:
+            file_path = file["path"] if isinstance(file, dict) and "path" in file else file
+
+            # If it's a relative path like "flow_id/filename", resolve it to cache dir
+            path = Path(file_path)
+            if not path.is_absolute() and not path.exists():
+                # Check if it exists in the cache directory
+                cache_path = cache_dir / file_path
+                if cache_path.exists():
+                    extracted_files.append(str(cache_path))
+                else:
+                    # Keep the original path if not found
+                    extracted_files.append(file_path)
+            else:
+                extracted_files.append(file_path)
+        return extracted_files
+
+    file_paths = []
+    for file in files:
+        # Handle dict case
+        if storage_service is None:
+            continue
+        if isinstance(file, dict) and "path" in file:
+            file_path = Path(file["path"])
+        elif hasattr(file, "path") and file.path:
+            file_path = Path(file.path)
+        else:
+            file_path = Path(file)
+        flow_id, file_name = str(file_path.parent), file_path.name
+        file_paths.append(storage_service.build_full_path(flow_id=flow_id, file_name=file_name))
+    return file_paths
+
+
+async def get_files(
+    file_paths: list[str],
+    *,
+    convert_to_base64: bool = False,
+):
+    """Get files from storage service."""
+    storage_service = get_storage_service()
+    if not storage_service:
+        # For testing purposes, read files directly when no storage service
+        file_objects: list[str | bytes] = []
+        for file_path_str in file_paths:
+            file_path = Path(file_path_str)
+            if file_path.exists():
+                # Use async read for compatibility
+
+                async with aiofiles.open(file_path, "rb") as f:
+                    file_content = await f.read()
+                if convert_to_base64:
+                    file_base64 = base64.b64encode(file_content).decode("utf-8")
+                    file_objects.append(file_base64)
+                else:
+                    file_objects.append(file_content)
+            else:
+                msg = f"File not found: {file_path}"
+                raise FileNotFoundError(msg)
+        return file_objects
+
+    file_objects: list[str | bytes] = []
+    for file in file_paths:
+        file_path = Path(file)
+        flow_id, file_name = str(file_path.parent), file_path.name
+        if not storage_service:
+            continue
+        file_object = await storage_service.get_file(flow_id=flow_id, file_name=file_name)
+        if convert_to_base64:
+            file_base64 = base64.b64encode(file_object).decode("utf-8")
+            file_objects.append(file_base64)
+        else:
+            file_objects.append(file_object)
+    return file_objects
+
+
+class Image(BaseModel):
+    """Image model for lfx package."""
+
+    path: str | None = None
+    url: str | None = None
+
+    def to_base64(self):
+        """Convert image to base64 string."""
+        if self.path:
+            files = get_files([self.path], convert_to_base64=True)
+            return files[0]
+        msg = "Image path is not set."
+        raise ValueError(msg)
+
+    def to_content_dict(self):
+        """Convert image to content dictionary."""
+        return {
+            "type": "image_url",
+            "image_url": self.to_base64(),
+        }
+
+    def get_url(self) -> str:
+        """Get the URL for the image."""
+        return f"{IMAGE_ENDPOINT}{self.path}"

lfx/schema/json_schema.py

@@ -0,0 +1,141 @@
+"""JSON Schema utilities for LFX."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field, create_model
+
+from lfx.log.logger import logger
+
+NULLABLE_TYPE_LENGTH = 2  # Number of types in a nullable union (the type itself + null)
+
+
+def create_input_schema_from_json_schema(schema: dict[str, Any]) -> type[BaseModel]:
+    """Dynamically build a Pydantic model from a JSON schema (with $defs).
+
+    Non-required fields become Optional[...] with default=None.
+    """
+    if schema.get("type") != "object":
+        msg = "Root schema must be type 'object'"
+        raise ValueError(msg)
+
+    defs: dict[str, dict[str, Any]] = schema.get("$defs", {})
+    model_cache: dict[str, type[BaseModel]] = {}
+
+    def resolve_ref(s: dict[str, Any] | None) -> dict[str, Any]:
+        """Follow a $ref chain until you land on a real subschema."""
+        if s is None:
+            return {}
+        while "$ref" in s:
+            ref_name = s["$ref"].split("/")[-1]
+            s = defs.get(ref_name)
+            if s is None:
+                logger.warning(f"Parsing input schema: Definition '{ref_name}' not found")
+                return {"type": "string"}
+        return s
+
+    def parse_type(s: dict[str, Any] | None) -> Any:
+        """Map a JSON Schema subschema to a Python type (possibly nested)."""
+        if s is None:
+            return None
+        s = resolve_ref(s)
+
+        if "anyOf" in s:
+            # Handle common pattern for nullable types (anyOf with string and null)
+            subtypes = [sub.get("type") for sub in s["anyOf"] if isinstance(sub, dict) and "type" in sub]
+
+            # Check if this is a simple nullable type (e.g., str | None)
+            if len(subtypes) == NULLABLE_TYPE_LENGTH and "null" in subtypes:
+                # Get the non-null type
+                non_null_type = next(t for t in subtypes if t != "null")
+                # Map it to Python type
+                if isinstance(non_null_type, str):
+                    return {
+                        "string": str,
+                        "integer": int,
+                        "number": float,
+                        "boolean": bool,
+                        "object": dict,
+                        "array": list,
+                    }.get(non_null_type, Any)
+                return Any
+
+            # For other anyOf cases, use the first non-null type
+            subtypes = [parse_type(sub) for sub in s["anyOf"]]
+            non_null_types = [t for t in subtypes if t is not None and t is not type(None)]
+            if non_null_types:
+                return non_null_types[0]
+            return str
+
+        t = s.get("type", "any")  # Use string "any" as default instead of Any type
+        if t == "array":
+            item_schema = s.get("items", {})
+            schema_type: Any = parse_type(item_schema)
+            return list[schema_type]
+
+        if t == "object":
+            # inline object not in $defs ⇒ anonymous nested model
+            return _build_model(f"AnonModel{len(model_cache)}", s)
+
+        # primitive fallback
+        return {
+            "string": str,
+            "integer": int,
+            "number": float,
+            "boolean": bool,
+            "object": dict,
+            "array": list,
+        }.get(t, Any)
+
+    def _build_model(name: str, subschema: dict[str, Any]) -> type[BaseModel]:
+        """Create (or fetch) a BaseModel subclass for the given object schema."""
+        # If this came via a named $ref, use that name
+        if "$ref" in subschema:
+            refname = subschema["$ref"].split("/")[-1]
+            if refname in model_cache:
+                return model_cache[refname]
+            target = defs.get(refname)
+            if not target:
+                msg = f"Definition '{refname}' not found"
+                raise ValueError(msg)
+            cls = _build_model(refname, target)
+            model_cache[refname] = cls
+            return cls
+
+        # Named anonymous or inline: avoid clashes by name
+        if name in model_cache:
+            return model_cache[name]
+
+        props = subschema.get("properties", {})
+        reqs = set(subschema.get("required", []))
+        fields: dict[str, Any] = {}
+
+        for prop_name, prop_schema in props.items():
+            py_type = parse_type(prop_schema)
+            is_required = prop_name in reqs
+            if not is_required:
+                py_type = py_type | None
+                default = prop_schema.get("default", None)
+            else:
+                default = ...  # required by Pydantic
+
+            fields[prop_name] = (py_type, Field(default, description=prop_schema.get("description")))
+
+        model_cls = create_model(name, **fields)
+        model_cache[name] = model_cls
+        return model_cls
+
+    # build the top - level "InputSchema" from the root properties
+    top_props = schema.get("properties", {})
+    top_reqs = set(schema.get("required", []))
+    top_fields: dict[str, Any] = {}
+
+    for fname, fdef in top_props.items():
+        py_type = parse_type(fdef)
+        if fname not in top_reqs:
+            py_type = py_type | None
+            default = fdef.get("default", None)
+        else:
+            default = ...
+        top_fields[fname] = (py_type, Field(default, description=fdef.get("description")))
+
+    return create_model("InputSchema", **top_fields)

lfx/schema/log.py

@@ -0,0 +1,61 @@
+"""Log schema and types for lfx package."""
+
+from typing import Any, Literal, TypeAlias
+
+from pydantic import BaseModel, field_serializer
+from pydantic_core import PydanticSerializationError
+from typing_extensions import Protocol
+
+from lfx.schema.message import ContentBlock, Message
+from lfx.serialization.serialization import serialize
+
+# Simplified LoggableType without PlaygroundEvent dependency
+LoggableType: TypeAlias = str | dict | list | int | float | bool | BaseModel | None
+
+
+class LogFunctionType(Protocol):
+    """Protocol for log function type."""
+
+    def __call__(self, message: LoggableType | list[LoggableType], *, name: str | None = None) -> None: ...
+
+
+class SendMessageFunctionType(Protocol):
+    """Protocol for send message function type."""
+
+    async def __call__(
+        self,
+        message: Message | None = None,
+        text: str | None = None,
+        background_color: str | None = None,
+        text_color: str | None = None,
+        icon: str | None = None,
+        content_blocks: list[ContentBlock] | None = None,
+        format_type: Literal["default", "error", "warning", "info"] = "default",
+        id_: str | None = None,
+        *,
+        allow_markdown: bool = True,
+    ) -> Message: ...
+
+
+class OnTokenFunctionType(Protocol):
+    """Protocol for on token function type."""
+
+    def __call__(self, data: dict[str, Any]) -> None: ...
+
+
+class Log(BaseModel):
+    """Log model for storing log messages with serialization support."""
+
+    name: str
+    message: LoggableType
+    type: str
+
+    @field_serializer("message")
+    def serialize_message(self, value):
+        """Serialize the message field with fallback error handling."""
+        try:
+            return serialize(value)
+        except UnicodeDecodeError:
+            return str(value)  # Fallback to string representation
+        except PydanticSerializationError:
+            return str(value)  # Fallback to string for Pydantic errors