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

lfx/custom/validate.py

@@ -0,0 +1,488 @@
+import ast
+import contextlib
+import importlib
+import warnings
+from types import FunctionType
+from typing import Optional, Union
+
+from langchain_core._api.deprecation import LangChainDeprecationWarning
+from pydantic import ValidationError
+
+from lfx.field_typing.constants import CUSTOM_COMPONENT_SUPPORTED_TYPES, DEFAULT_IMPORT_STRING
+from lfx.log.logger import logger
+
+_LANGFLOW_IS_INSTALLED = False
+
+with contextlib.suppress(ImportError):
+    import langflow  # noqa: F401
+
+    _LANGFLOW_IS_INSTALLED = True
+
+
+def add_type_ignores() -> None:
+    if not hasattr(ast, "TypeIgnore"):
+
+        class TypeIgnore(ast.AST):
+            _fields = ()
+
+        ast.TypeIgnore = TypeIgnore  # type: ignore[assignment, misc]
+
+
+def validate_code(code):
+    # Initialize the errors dictionary
+    errors = {"imports": {"errors": []}, "function": {"errors": []}}
+
+    # Parse the code string into an abstract syntax tree (AST)
+    try:
+        tree = ast.parse(code)
+    except Exception as e:  # noqa: BLE001
+        if hasattr(logger, "opt"):
+            logger.debug("Error parsing code", exc_info=True)
+        else:
+            logger.debug("Error parsing code")
+        errors["function"]["errors"].append(str(e))
+        return errors
+
+    # Add a dummy type_ignores field to the AST
+    add_type_ignores()
+    tree.type_ignores = []
+
+    # Evaluate the import statements
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                try:
+                    importlib.import_module(alias.name)
+                except ModuleNotFoundError as e:
+                    errors["imports"]["errors"].append(str(e))
+
+    # Evaluate the function definition with langflow context
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef):
+            code_obj = compile(ast.Module(body=[node], type_ignores=[]), "<string>", "exec")
+            try:
+                # Create execution context with common langflow imports
+                exec_globals = _create_langflow_execution_context()
+                exec(code_obj, exec_globals)
+            except Exception as e:  # noqa: BLE001
+                logger.debug("Error executing function code", exc_info=True)
+                errors["function"]["errors"].append(str(e))
+
+    # Return the errors dictionary
+    return errors
+
+
+def _create_langflow_execution_context():
+    """Create execution context with common langflow imports."""
+    context = {}
+
+    # Import common langflow types that are used in templates
+    try:
+        from lfx.schema.dataframe import DataFrame
+
+        context["DataFrame"] = DataFrame
+    except ImportError:
+        # Create a mock DataFrame if import fails
+        context["DataFrame"] = type("DataFrame", (), {})
+
+    try:
+        from lfx.schema.message import Message
+
+        context["Message"] = Message
+    except ImportError:
+        context["Message"] = type("Message", (), {})
+
+    try:
+        from lfx.schema.data import Data
+
+        context["Data"] = Data
+    except ImportError:
+        context["Data"] = type("Data", (), {})
+
+    try:
+        from lfx.custom import Component
+
+        context["Component"] = Component
+    except ImportError:
+        context["Component"] = type("Component", (), {})
+
+    try:
+        from lfx.io import HandleInput, Output, TabInput
+
+        context["HandleInput"] = HandleInput
+        context["Output"] = Output
+        context["TabInput"] = TabInput
+    except ImportError:
+        context["HandleInput"] = type("HandleInput", (), {})
+        context["Output"] = type("Output", (), {})
+        context["TabInput"] = type("TabInput", (), {})
+
+    # Add common Python typing imports
+    try:
+        from typing import Any, Optional, Union
+
+        context["Any"] = Any
+        context["Dict"] = dict
+        context["List"] = list
+        context["Optional"] = Optional
+        context["Union"] = Union
+    except ImportError:
+        pass
+
+    return context
+
+
+def eval_function(function_string: str):
+    # Create an empty dictionary to serve as a separate namespace
+    namespace: dict = {}
+
+    # Execute the code string in the new namespace
+    exec(function_string, namespace)
+    function_object = next(
+        (
+            obj
+            for name, obj in namespace.items()
+            if isinstance(obj, FunctionType) and obj.__code__.co_filename == "<string>"
+        ),
+        None,
+    )
+    if function_object is None:
+        msg = "Function string does not contain a function"
+        raise ValueError(msg)
+    return function_object
+
+
+def execute_function(code, function_name, *args, **kwargs):
+    add_type_ignores()
+
+    module = ast.parse(code)
+    exec_globals = globals().copy()
+
+    for node in module.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                try:
+                    exec(
+                        f"{alias.asname or alias.name} = importlib.import_module('{alias.name}')",
+                        exec_globals,
+                        locals(),
+                    )
+                    exec_globals[alias.asname or alias.name] = importlib.import_module(alias.name)
+                except ModuleNotFoundError as e:
+                    msg = f"Module {alias.name} not found. Please install it and try again."
+                    raise ModuleNotFoundError(msg) from e
+
+    function_code = next(
+        node for node in module.body if isinstance(node, ast.FunctionDef) and node.name == function_name
+    )
+    function_code.parent = None
+    code_obj = compile(ast.Module(body=[function_code], type_ignores=[]), "<string>", "exec")
+    exec_locals = dict(locals())
+    try:
+        exec(code_obj, exec_globals, exec_locals)
+    except Exception as exc:
+        msg = "Function string does not contain a function"
+        raise ValueError(msg) from exc
+
+    # Add the function to the exec_globals dictionary
+    exec_globals[function_name] = exec_locals[function_name]
+
+    return exec_globals[function_name](*args, **kwargs)
+
+
+def create_function(code, function_name):
+    if not hasattr(ast, "TypeIgnore"):
+
+        class TypeIgnore(ast.AST):
+            _fields = ()
+
+        ast.TypeIgnore = TypeIgnore
+
+    module = ast.parse(code)
+    exec_globals = globals().copy()
+
+    for node in module.body:
+        if isinstance(node, ast.Import | ast.ImportFrom):
+            for alias in node.names:
+                try:
+                    if isinstance(node, ast.ImportFrom):
+                        module_name = node.module
+                        exec_globals[alias.asname or alias.name] = getattr(
+                            importlib.import_module(module_name), alias.name
+                        )
+                    else:
+                        module_name = alias.name
+                        exec_globals[alias.asname or alias.name] = importlib.import_module(module_name)
+                except ModuleNotFoundError as e:
+                    msg = f"Module {alias.name} not found. Please install it and try again."
+                    raise ModuleNotFoundError(msg) from e
+
+    function_code = next(
+        node for node in module.body if isinstance(node, ast.FunctionDef) and node.name == function_name
+    )
+    function_code.parent = None
+    code_obj = compile(ast.Module(body=[function_code], type_ignores=[]), "<string>", "exec")
+    exec_locals = dict(locals())
+    with contextlib.suppress(Exception):
+        exec(code_obj, exec_globals, exec_locals)
+    exec_globals[function_name] = exec_locals[function_name]
+
+    # Return a function that imports necessary modules and calls the target function
+    def wrapped_function(*args, **kwargs):
+        for module_name, module in exec_globals.items():
+            if isinstance(module, type(importlib)):
+                globals()[module_name] = module
+
+        return exec_globals[function_name](*args, **kwargs)
+
+    return wrapped_function
+
+
+def create_class(code, class_name):
+    """Dynamically create a class from a string of code and a specified class name.
+
+    Args:
+        code: String containing the Python code defining the class
+        class_name: Name of the class to be created
+
+    Returns:
+         A function that, when called, returns an instance of the created class
+
+    Raises:
+        ValueError: If the code contains syntax errors or the class definition is invalid
+    """
+    if not hasattr(ast, "TypeIgnore"):
+        ast.TypeIgnore = create_type_ignore_class()
+
+    code = code.replace("from langflow import CustomComponent", "from langflow.custom import CustomComponent")
+    code = code.replace(
+        "from langflow.interface.custom.custom_component import CustomComponent",
+        "from langflow.custom import CustomComponent",
+    )
+
+    code = DEFAULT_IMPORT_STRING + "\n" + code
+    try:
+        module = ast.parse(code)
+        exec_globals = prepare_global_scope(module)
+
+        class_code = extract_class_code(module, class_name)
+        compiled_class = compile_class_code(class_code)
+
+        return build_class_constructor(compiled_class, exec_globals, class_name)
+
+    except SyntaxError as e:
+        msg = f"Syntax error in code: {e!s}"
+        raise ValueError(msg) from e
+    except NameError as e:
+        msg = f"Name error (possibly undefined variable): {e!s}"
+        raise ValueError(msg) from e
+    except ValidationError as e:
+        messages = [error["msg"].split(",", 1) for error in e.errors()]
+        error_message = "\n".join([message[1] if len(message) > 1 else message[0] for message in messages])
+        raise ValueError(error_message) from e
+    except Exception as e:
+        msg = f"Error creating class: {e!s}"
+        raise ValueError(msg) from e
+
+
+def create_type_ignore_class():
+    """Create a TypeIgnore class for AST module if it doesn't exist.
+
+    Returns:
+        TypeIgnore class
+    """
+
+    class TypeIgnore(ast.AST):
+        _fields = ()
+
+    return TypeIgnore
+
+
+def prepare_global_scope(module):
+    """Prepares the global scope with necessary imports from the provided code module.
+
+    Args:
+        module: AST parsed module
+
+    Returns:
+        Dictionary representing the global scope with imported modules
+
+    Raises:
+        ModuleNotFoundError: If a module is not found in the code
+    """
+    exec_globals = globals().copy()
+    imports = []
+    import_froms = []
+    definitions = []
+
+    for node in module.body:
+        if isinstance(node, ast.Import):
+            imports.append(node)
+        elif isinstance(node, ast.ImportFrom) and node.module is not None:
+            import_froms.append(node)
+        elif isinstance(node, ast.ClassDef | ast.FunctionDef | ast.Assign):
+            definitions.append(node)
+
+    for node in imports:
+        for alias in node.names:
+            try:
+                module_name = alias.name
+                variable_name = alias.asname or alias.name
+                exec_globals[variable_name] = importlib.import_module(module_name)
+            except ModuleNotFoundError as e:
+                msg = f"Module {alias.name} not found. Please install it and try again."
+                raise ModuleNotFoundError(msg) from e
+
+    for node in import_froms:
+        try:
+            module_name = node.module
+            # Apply warning suppression only when needed
+            if "langchain" in module_name:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", LangChainDeprecationWarning)
+                    imported_module = importlib.import_module(module_name)
+            else:
+                imported_module = importlib.import_module(module_name)
+
+            for alias in node.names:
+                try:
+                    # First try getting it as an attribute
+                    exec_globals[alias.name] = getattr(imported_module, alias.name)
+                except AttributeError:
+                    # If that fails, try importing the full module path
+                    full_module_path = f"{module_name}.{alias.name}"
+                    exec_globals[alias.name] = importlib.import_module(full_module_path)
+        except ModuleNotFoundError as e:
+            msg = f"Module {node.module} not found. Please install it and try again"
+            raise ModuleNotFoundError(msg) from e
+
+    if definitions:
+        combined_module = ast.Module(body=definitions, type_ignores=[])
+        compiled_code = compile(combined_module, "<string>", "exec")
+        exec(compiled_code, exec_globals)
+
+    return exec_globals
+
+
+def extract_class_code(module, class_name):
+    """Extracts the AST node for the specified class from the module.
+
+    Args:
+        module: AST parsed module
+        class_name: Name of the class to extract
+
+    Returns:
+        AST node of the specified class
+    """
+    class_code = next(node for node in module.body if isinstance(node, ast.ClassDef) and node.name == class_name)
+
+    class_code.parent = None
+    return class_code
+
+
+def compile_class_code(class_code):
+    """Compiles the AST node of a class into a code object.
+
+    Args:
+        class_code: AST node of the class
+
+    Returns:
+        Compiled code object of the class
+    """
+    return compile(ast.Module(body=[class_code], type_ignores=[]), "<string>", "exec")
+
+
+def build_class_constructor(compiled_class, exec_globals, class_name):
+    """Builds a constructor function for the dynamically created class.
+
+    Args:
+        compiled_class: Compiled code object of the class
+        exec_globals: Global scope with necessary imports
+        class_name: Name of the class
+
+    Returns:
+         Constructor function for the class
+    """
+    exec_locals = dict(locals())
+    exec(compiled_class, exec_globals, exec_locals)
+    exec_globals[class_name] = exec_locals[class_name]
+
+    # Return a function that imports necessary modules and creates an instance of the target class
+    def build_custom_class():
+        for module_name, module in exec_globals.items():
+            if isinstance(module, type(importlib)):
+                globals()[module_name] = module
+
+        return exec_globals[class_name]
+
+    return build_custom_class()
+
+
+# TODO: Remove this function
+def get_default_imports(code_string):
+    """Returns a dictionary of default imports for the dynamic class constructor."""
+    default_imports = {
+        "Optional": Optional,
+        "List": list,
+        "Dict": dict,
+        "Union": Union,
+    }
+    langflow_imports = list(CUSTOM_COMPONENT_SUPPORTED_TYPES.keys())
+    necessary_imports = find_names_in_code(code_string, langflow_imports)
+    langflow_module = importlib.import_module("lfx.field_typing")
+    default_imports.update({name: getattr(langflow_module, name) for name in necessary_imports})
+
+    return default_imports
+
+
+def find_names_in_code(code, names):
+    """Finds if any of the specified names are present in the given code string.
+
+    Args:
+        code: The source code as a string.
+        names: A list of names to check for in the code.
+
+    Returns:
+        A set of names that are found in the code.
+    """
+    return {name for name in names if name in code}
+
+
+def extract_function_name(code):
+    module = ast.parse(code)
+    for node in module.body:
+        if isinstance(node, ast.FunctionDef):
+            return node.name
+    msg = "No function definition found in the code string"
+    raise ValueError(msg)
+
+
+def extract_class_name(code: str) -> str:
+    """Extract the name of the first Component subclass found in the code.
+
+    Args:
+        code (str): The source code to parse
+
+    Returns:
+        str: Name of the first Component subclass found
+
+    Raises:
+        TypeError: If no Component subclass is found in the code
+    """
+    try:
+        module = ast.parse(code)
+        for node in module.body:
+            if not isinstance(node, ast.ClassDef):
+                continue
+
+            # Check bases for Component inheritance
+            # TODO: Build a more robust check for Component inheritance
+            for base in node.bases:
+                if isinstance(base, ast.Name) and any(pattern in base.id for pattern in ["Component", "LC"]):
+                    return node.name
+
+        msg = f"No Component subclass found in the code string. Code snippet: {code[:100]}"
+        raise TypeError(msg)
+    except SyntaxError as e:
+        msg = f"Invalid Python code: {e!s}"
+        raise ValueError(msg) from e

lfx/events/__init__.py

@@ -0,0 +1 @@
+# Event management for lfx package

lfx/events/event_manager.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import inspect
+import json
+import time
+import uuid
+from functools import partial
+from typing import TYPE_CHECKING
+
+from fastapi.encoders import jsonable_encoder
+from typing_extensions import Protocol
+
+from lfx.log.logger import logger
+
+if TYPE_CHECKING:
+    # Lightweight type stub for log types
+    LoggableType = dict | str | int | float | bool | list | None
+
+
+class EventCallback(Protocol):
+    def __call__(self, *, manager: EventManager, event_type: str, data: LoggableType): ...
+
+
+class PartialEventCallback(Protocol):
+    def __call__(self, *, data: LoggableType): ...
+
+
+class EventManager:
+    def __init__(self, queue):
+        self.queue = queue
+        self.events: dict[str, PartialEventCallback] = {}
+
+    @staticmethod
+    def _validate_callback(callback: EventCallback) -> None:
+        if not callable(callback):
+            msg = "Callback must be callable"
+            raise TypeError(msg)
+        # Check if it has `self, event_type and data`
+        sig = inspect.signature(callback)
+        parameters = ["manager", "event_type", "data"]
+        if len(sig.parameters) != len(parameters):
+            msg = "Callback must have exactly 3 parameters"
+            raise ValueError(msg)
+        if not all(param.name in parameters for param in sig.parameters.values()):
+            msg = "Callback must have exactly 3 parameters: manager, event_type, and data"
+            raise ValueError(msg)
+
+    def register_event(
+        self,
+        name: str,
+        event_type: str,
+        callback: EventCallback | None = None,
+    ) -> None:
+        if not name:
+            msg = "Event name cannot be empty"
+            raise ValueError(msg)
+        if not name.startswith("on_"):
+            msg = "Event name must start with 'on_'"
+            raise ValueError(msg)
+        if callback is None:
+            callback_ = partial(self.send_event, event_type=event_type)
+        else:
+            callback_ = partial(callback, manager=self, event_type=event_type)
+        self.events[name] = callback_
+
+    def send_event(self, *, event_type: str, data: LoggableType):
+        try:
+            # Simple event creation without heavy dependencies
+            if isinstance(data, dict) and event_type in {"message", "error", "warning", "info", "token"}:
+                # For lfx, keep it simple without playground event creation
+                pass
+        except Exception:  # noqa: BLE001
+            logger.debug(f"Error processing event: {event_type}")
+        jsonable_data = jsonable_encoder(data)
+        json_data = {"event": event_type, "data": jsonable_data}
+        event_id = f"{event_type}-{uuid.uuid4()}"
+        str_data = json.dumps(json_data) + "\n\n"
+        if self.queue:
+            try:
+                self.queue.put_nowait((event_id, str_data.encode("utf-8"), time.time()))
+            except Exception:  # noqa: BLE001
+                logger.debug("Queue not available for event")
+
+    def noop(self, *, data: LoggableType) -> None:
+        pass
+
+    def __getattr__(self, name: str) -> PartialEventCallback:
+        return self.events.get(name, self.noop)
+
+
+def create_default_event_manager(queue=None):
+    manager = EventManager(queue)
+    manager.register_event("on_token", "token")
+    manager.register_event("on_vertices_sorted", "vertices_sorted")
+    manager.register_event("on_error", "error")
+    manager.register_event("on_end", "end")
+    manager.register_event("on_message", "add_message")
+    manager.register_event("on_remove_message", "remove_message")
+    manager.register_event("on_end_vertex", "end_vertex")
+    manager.register_event("on_build_start", "build_start")
+    manager.register_event("on_build_end", "build_end")
+    return manager
+
+
+def create_stream_tokens_event_manager(queue=None):
+    manager = EventManager(queue)
+    manager.register_event("on_message", "add_message")
+    manager.register_event("on_token", "token")
+    manager.register_event("on_end", "end")
+    return manager

lfx/exceptions/component.py

@@ -0,0 +1,15 @@
+from lfx.schema.properties import Source
+
+
+class ComponentBuildError(Exception):
+    def __init__(self, message: str, formatted_traceback: str):
+        self.message = message
+        self.formatted_traceback = formatted_traceback
+        super().__init__(message)
+
+
+class StreamingError(Exception):
+    def __init__(self, cause: Exception, source: Source):
+        self.cause = cause
+        self.source = source
+        super().__init__(cause)

lfx/field_typing/__init__.py

@@ -0,0 +1,91 @@
+from typing import Any
+
+from .constants import (
+    AgentExecutor,
+    BaseChatMemory,
+    BaseChatModel,
+    BaseDocumentCompressor,
+    BaseLanguageModel,
+    BaseLLM,
+    BaseLoader,
+    BaseMemory,
+    BaseOutputParser,
+    BasePromptTemplate,
+    BaseRetriever,
+    Callable,
+    Chain,
+    ChatPromptTemplate,
+    Code,
+    Data,
+    Document,
+    Embeddings,
+    LanguageModel,
+    NestedDict,
+    Object,
+    PromptTemplate,
+    Retriever,
+    Text,
+    TextSplitter,
+    Tool,
+    VectorStore,
+)
+from .range_spec import RangeSpec
+
+
+def _import_input_class():
+    from lfx.template.field.base import Input
+
+    return Input
+
+
+def _import_output_class():
+    from lfx.template.field.base import Output
+
+    return Output
+
+
+def __getattr__(name: str) -> Any:
+    # This is to avoid circular imports
+    if name == "Input":
+        return _import_input_class()
+    if name == "Output":
+        return _import_output_class()
+    if name == "RangeSpec":
+        return RangeSpec
+    # The other names should work as if they were imported from constants
+    # Import the constants module langflow.field_typing.constants
+    from . import constants
+
+    return getattr(constants, name)
+
+
+__all__ = [
+    "AgentExecutor",
+    "BaseChatMemory",
+    "BaseChatModel",
+    "BaseDocumentCompressor",
+    "BaseLLM",
+    "BaseLanguageModel",
+    "BaseLoader",
+    "BaseMemory",
+    "BaseOutputParser",
+    "BasePromptTemplate",
+    "BaseRetriever",
+    "Callable",
+    "Chain",
+    "ChatPromptTemplate",
+    "Code",
+    "Data",
+    "Document",
+    "Embeddings",
+    "LanguageModel",
+    "NestedDict",
+    "Object",
+    "PromptTemplate",
+    "RangeSpec",
+    "Retriever",
+    "Text",
+    "TextSplitter",
+    "Tool",
+    "VectorStore",
+]