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

lfx/utils/data_structure.py

@@ -0,0 +1,212 @@
+import json
+from collections import Counter
+from typing import Any
+
+from lfx.schema.data import Data
+
+
+def infer_list_type(items: list, max_samples: int = 5) -> str:
+    """Infer the type of a list by sampling its items.
+
+    Handles mixed types and provides more detailed type information.
+    """
+    if not items:
+        return "list(unknown)"
+
+    # Sample items (use all if less than max_samples)
+    samples = items[:max_samples]
+    types = [get_type_str(item) for item in samples]
+
+    # Count type occurrences
+    type_counter = Counter(types)
+
+    if len(type_counter) == 1:
+        # Single type
+        return f"list({types[0]})"
+    # Mixed types - show all found types
+    type_str = "|".join(sorted(type_counter.keys()))
+    return f"list({type_str})"
+
+
+def get_type_str(value: Any) -> str:
+    """Get a detailed string representation of the type of a value.
+
+    Handles special cases and provides more specific type information.
+    """
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "bool"
+    if isinstance(value, int):
+        return "int"
+    if isinstance(value, float):
+        return "float"
+    if isinstance(value, str):
+        # Check if string is actually a date/datetime
+        if any(date_pattern in value.lower() for date_pattern in ["date", "time", "yyyy", "mm/dd", "dd/mm", "yyyy-mm"]):
+            return "str(possible_date)"
+        # Check if it's a JSON string
+        try:
+            json.loads(value)
+            return "str(json)"
+        except (json.JSONDecodeError, TypeError):
+            pass
+        else:
+            return "str"
+    if isinstance(value, list | tuple | set):
+        return infer_list_type(list(value))
+    if isinstance(value, dict):
+        return "dict"
+    # Handle custom objects
+    return type(value).__name__
+
+
+def analyze_value(
+    value: Any,
+    max_depth: int = 10,
+    current_depth: int = 0,
+    path: str = "",
+    *,
+    size_hints: bool = True,
+    include_samples: bool = True,
+) -> str | dict:
+    """Analyze a value and return its structure with additional metadata.
+
+    Args:
+        value: The value to analyze
+        max_depth: Maximum recursion depth
+        current_depth: Current recursion depth
+        path: Current path in the structure
+        size_hints: Whether to include size information for collections
+        include_samples: Whether to include sample structure for lists
+    """
+    if current_depth >= max_depth:
+        return f"max_depth_reached(depth={max_depth})"
+
+    try:
+        if isinstance(value, list | tuple | set):
+            length = len(value)
+            if length == 0:
+                return "list(unknown)"
+
+            type_info = infer_list_type(list(value))
+            size_info = f"[size={length}]" if size_hints else ""
+
+            # For lists of complex objects, include a sample of the structure
+            if (
+                include_samples
+                and length > 0
+                and isinstance(value, list | tuple)
+                and isinstance(value[0], dict | list)
+                and current_depth < max_depth - 1
+            ):
+                sample = analyze_value(
+                    value[0],
+                    max_depth,
+                    current_depth + 1,
+                    f"{path}[0]",
+                    size_hints=size_hints,
+                    include_samples=include_samples,
+                )
+                return f"{type_info}{size_info}, sample: {json.dumps(sample)}"
+
+            return f"{type_info}{size_info}"
+
+        if isinstance(value, dict):
+            result = {}
+            for k, v in value.items():
+                new_path = f"{path}.{k}" if path else k
+                try:
+                    result[k] = analyze_value(
+                        v,
+                        max_depth,
+                        current_depth + 1,
+                        new_path,
+                        size_hints=size_hints,
+                        include_samples=include_samples,
+                    )
+                except Exception as e:  # noqa: BLE001
+                    result[k] = f"error({e!s})"
+            return result
+
+        return get_type_str(value)
+
+    except Exception as e:  # noqa: BLE001
+        return f"error({e!s})"
+
+
+def get_data_structure(
+    data_obj: Data | dict,
+    max_depth: int = 10,
+    max_sample_size: int = 3,
+    *,
+    size_hints: bool = True,
+    include_sample_values: bool = False,
+    include_sample_structure: bool = True,
+) -> dict:
+    """Convert a Data object or dictionary into a detailed schema representation.
+
+    Args:
+        data_obj: The Data object or dictionary to analyze
+        max_depth: Maximum depth for nested structures
+        size_hints: Include size information for collections
+        include_sample_values: Whether to include sample values in the output
+        include_sample_structure: Whether to include sample structure for lists
+        max_sample_size: Maximum number of sample values to include
+
+    Returns:
+        dict: A dictionary containing:
+            - structure: The structure of the data
+            - samples: (optional) Sample values from the data
+
+    Example:
+        >>> data = {
+        ...     "name": "John",
+        ...     "scores": [1, 2, 3, 4, 5],
+        ...     "details": {
+        ...         "age": 30,
+        ...         "cities": ["NY", "LA", "SF", "CHI"],
+        ...         "metadata": {
+        ...             "created": "2023-01-01",
+        ...             "tags": ["user", "admin", 123]
+        ...         }
+        ...     }
+        ... }
+        >>> result = get_data_structure(data)
+        {
+            "structure": {
+                "name": "str",
+                "scores": "list(int)[size=5]",
+                "details": {
+                    "age": "int",
+                    "cities": "list(str)[size=4]",
+                    "metadata": {
+                        "created": "str(possible_date)",
+                        "tags": "list(str|int)[size=3]"
+                    }
+                }
+            }
+        }
+    """
+    # Handle both Data objects and dictionaries
+    data = data_obj.data if isinstance(data_obj, Data) else data_obj
+
+    result = {
+        "structure": analyze_value(
+            data, max_depth=max_depth, size_hints=size_hints, include_samples=include_sample_structure
+        )
+    }
+
+    if include_sample_values:
+        result["samples"] = get_sample_values(data, max_items=max_sample_size)
+
+    return result
+
+
+def get_sample_values(data: Any, max_items: int = 3) -> Any:
+    """Get sample values from a data structure, handling nested structures."""
+    if isinstance(data, list | tuple | set):
+        return [get_sample_values(item) for item in list(data)[:max_items]]
+    if isinstance(data, dict):
+        return {k: get_sample_values(v, max_items) for k, v in data.items()}
+    return data

lfx/utils/exceptions.py

@@ -0,0 +1,22 @@
+def format_syntax_error_message(exc: SyntaxError) -> str:
+    """Format a SyntaxError message for returning to the frontend."""
+    if exc.text is None:
+        return f"Syntax error in code. Error on line {exc.lineno}"
+    return f"Syntax error in code. Error on line {exc.lineno}: {exc.text.strip()}"
+
+
+def get_causing_exception(exc: BaseException) -> BaseException:
+    """Get the causing exception from an exception."""
+    if hasattr(exc, "__cause__") and exc.__cause__:
+        return get_causing_exception(exc.__cause__)
+    return exc
+
+
+def format_exception_message(exc: Exception) -> str:
+    """Format an exception message for returning to the frontend."""
+    # We need to check if the __cause__ is a SyntaxError
+    # If it is, we need to return the message of the SyntaxError
+    causing_exception = get_causing_exception(exc)
+    if isinstance(causing_exception, SyntaxError):
+        return format_syntax_error_message(causing_exception)
+    return str(exc)

lfx/utils/helpers.py

@@ -0,0 +1,28 @@
+"""Helper utility functions for lfx package."""
+
+from __future__ import annotations
+
+import mimetypes
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def get_mime_type(file_path: str | Path) -> str:
+    """Get the MIME type of a file based on its extension.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        MIME type string (e.g., 'image/jpeg', 'image/png')
+
+    Raises:
+        ValueError: If MIME type cannot be determined
+    """
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    if mime_type is None:
+        msg = f"Could not determine MIME type for: {file_path}"
+        raise ValueError(msg)
+    return mime_type

lfx/utils/image.py

@@ -0,0 +1,73 @@
+"""Image utility functions for lfx package."""
+
+from __future__ import annotations
+
+import base64
+from functools import lru_cache
+from pathlib import Path
+
+from lfx.utils.helpers import get_mime_type
+
+
+def convert_image_to_base64(image_path: str | Path) -> str:
+    """Convert an image file to a base64 encoded string.
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        Base64 encoded string of the image
+
+    Raises:
+        FileNotFoundError: If the image file doesn't exist
+    """
+    image_path = Path(image_path)
+    if not image_path.exists():
+        msg = f"Image file not found: {image_path}"
+        raise FileNotFoundError(msg)
+
+    with image_path.open("rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str:
+    """Create a data URL from an image file.
+
+    Args:
+        image_path: Path to the image file
+        mime_type: MIME type of the image. If None, will be auto-detected
+
+    Returns:
+        Data URL string in format: data:mime/type;base64,{base64_data}
+
+    Raises:
+        FileNotFoundError: If the image file doesn't exist
+    """
+    image_path = Path(image_path)
+    if not image_path.exists():
+        msg = f"Image file not found: {image_path}"
+        raise FileNotFoundError(msg)
+
+    if mime_type is None:
+        mime_type = get_mime_type(image_path)
+
+    base64_data = convert_image_to_base64(image_path)
+    return f"data:{mime_type};base64,{base64_data}"
+
+
+@lru_cache(maxsize=50)
+def create_image_content_dict(image_path: str | Path, mime_type: str | None = None) -> dict:
+    """Create a content dictionary for multimodal inputs from an image file.
+
+    Args:
+        image_path: Path to the image file
+        mime_type: MIME type of the image. If None, will be auto-detected
+
+    Returns:
+        Content dictionary with type, source_type, and url fields
+
+    Raises:
+        FileNotFoundError: If the image file doesn't exist
+    """
+    data_url = create_data_url(image_path, mime_type)
+    return {"type": "image", "source_type": "url", "url": data_url}

lfx/utils/lazy_load.py

@@ -0,0 +1,15 @@
+class LazyLoadDictBase:
+    def __init__(self) -> None:
+        self._all_types_dict = None
+
+    @property
+    def all_types_dict(self):
+        if self._all_types_dict is None:
+            self._all_types_dict = self._build_dict()
+        return self._all_types_dict
+
+    def _build_dict(self):
+        raise NotImplementedError
+
+    def get_type_dict(self):
+        raise NotImplementedError

lfx/utils/request_utils.py

@@ -0,0 +1,18 @@
+from lfx.services.deps import get_settings_service
+
+DEFAULT_USER_AGENT = "Langflow"
+
+
+def get_user_agent():
+    """Get user agent with fallback."""
+    try:
+        settings_service = get_settings_service()
+        if (
+            settings_service
+            and hasattr(settings_service, "settings")
+            and hasattr(settings_service.settings, "user_agent")
+        ):
+            return settings_service.settings.user_agent
+    except (AttributeError, TypeError):
+        pass
+    return DEFAULT_USER_AGENT

lfx/utils/schemas.py

@@ -0,0 +1,139 @@
+import enum
+
+from langchain_core.messages import BaseMessage
+from pydantic import BaseModel, field_validator, model_validator
+from typing_extensions import TypedDict
+
+from .constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI
+
+# File types moved from lfx.base.data.utils
+TEXT_FILE_TYPES = [
+    "txt",
+    "md",
+    "mdx",
+    "csv",
+    "json",
+    "yaml",
+    "yml",
+    "xml",
+    "html",
+    "htm",
+    "pdf",
+    "docx",
+    "py",
+    "sh",
+    "sql",
+    "js",
+    "ts",
+    "tsx",
+]
+IMG_FILE_TYPES = ["jpg", "jpeg", "png", "bmp", "image"]
+
+
+class File(TypedDict):
+    """File schema."""
+
+    path: str
+    name: str
+    type: str
+
+
+class ChatOutputResponse(BaseModel):
+    """Chat output response schema."""
+
+    message: str | list[str | dict]
+    sender: str | None = MESSAGE_SENDER_AI
+    sender_name: str | None = MESSAGE_SENDER_NAME_AI
+    session_id: str | None = None
+    stream_url: str | None = None
+    component_id: str | None = None
+    files: list[File] = []
+    type: str
+
+    @field_validator("files", mode="before")
+    @classmethod
+    def validate_files(cls, files):
+        """Validate files."""
+        if not files:
+            return files
+
+        for file in files:
+            if not isinstance(file, dict):
+                msg = "Files must be a list of dictionaries."
+                raise ValueError(msg)  # noqa: TRY004
+
+            if not all(key in file for key in ["path", "name", "type"]):
+                # If any of the keys are missing, we should extract the
+                # values from the file path
+                path = file.get("path")
+                if not path:
+                    msg = "File path is required."
+                    raise ValueError(msg)
+
+                name = file.get("name")
+                if not name:
+                    name = path.split("/")[-1]
+                    file["name"] = name
+                type_ = file.get("type")
+                if not type_:
+                    # get the file type from the path
+                    extension = path.split(".")[-1]
+                    file_types = set(TEXT_FILE_TYPES + IMG_FILE_TYPES)
+                    if extension and extension in file_types:
+                        type_ = extension
+                    else:
+                        for file_type in file_types:
+                            if file_type in path:
+                                type_ = file_type
+                                break
+                    if not type_:
+                        msg = "File type is required."
+                        raise ValueError(msg)
+                file["type"] = type_
+
+        return files
+
+    @classmethod
+    def from_message(
+        cls,
+        message: BaseMessage,
+        sender: str | None = MESSAGE_SENDER_AI,
+        sender_name: str | None = MESSAGE_SENDER_NAME_AI,
+    ):
+        """Build chat output response from message."""
+        content = message.content
+        return cls(message=content, sender=sender, sender_name=sender_name)
+
+    @model_validator(mode="after")
+    def validate_message(self):
+        """Validate message."""
+        # The idea here is ensure the \n in message
+        # is compliant with markdown if sender is machine
+        # so, for example:
+        # \n\n -> \n\n
+        # \n -> \n\n
+
+        if self.sender != MESSAGE_SENDER_AI:
+            return self
+
+        # We need to make sure we don't duplicate \n
+        # in the message
+        message = self.message.replace("\n\n", "\n")
+        self.message = message.replace("\n", "\n\n")
+        return self
+
+
+class DataOutputResponse(BaseModel):
+    """Data output response schema."""
+
+    data: list[dict | None]
+
+
+class ContainsEnumMeta(enum.EnumMeta):
+    def __contains__(cls, item) -> bool:
+        try:
+            cls(item)
+        except ValueError:
+            return False
+        else:
+            return True