langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/utils/validate.py

@@ -1,489 +1,3 @@
-import ast
-import contextlib
-import importlib
-import warnings
-from types import FunctionType
-from typing import Optional, Union
+from lfx.custom.validate import *  # noqa: F403
 
-from langchain_core._api.deprecation import LangChainDeprecationWarning
-from pydantic import ValidationError
-
-from langflow.field_typing.constants import CUSTOM_COMPONENT_SUPPORTED_TYPES, DEFAULT_IMPORT_STRING
-from langflow.logging.logger import logger
-
-
-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 langflow.schema.dataframe import DataFrame
-
-        context["DataFrame"] = DataFrame
-    except ImportError:
-        # Create a mock DataFrame if import fails
-        context["DataFrame"] = type("DataFrame", (), {})
-
-    try:
-        from langflow.schema.message import Message
-
-        context["Message"] = Message
-    except ImportError:
-        context["Message"] = type("Message", (), {})
-
-    try:
-        from langflow.schema.data import Data
-
-        context["Data"] = Data
-    except ImportError:
-        context["Data"] = type("Data", (), {})
-
-    try:
-        from langflow.custom import Component
-
-        context["Component"] = Component
-    except ImportError:
-        context["Component"] = type("Component", (), {})
-
-    try:
-        from langflow.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
-
-    # Add other common imports that might be used
-    try:
-        import pandas as pd
-
-        context["pd"] = pd
-    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("langflow.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
+__all__ = [name for name in dir() if not name.startswith("_")]

langflow/utils/voice_utils.py

@@ -3,10 +3,9 @@ import base64
 from pathlib import Path
 
 import numpy as np
+from lfx.log import logger
 from scipy.signal import resample
 
-from langflow.logging import logger
-
 SAMPLE_RATE_24K = 24000
 VAD_SAMPLE_RATE_16K = 16000
 FRAME_DURATION_MS = 20

langflow/worker.py

@@ -8,7 +8,7 @@ from celery.exceptions import SoftTimeLimitExceeded
 from langflow.core.celery_app import celery_app
 
 if TYPE_CHECKING:
-    from langflow.graph.vertex.base import Vertex
+    from lfx.graph.vertex.base import Vertex
 
 
 @celery_app.task(acks_late=True)

{langflow_base_nightly-0.5.1.dev3.dist-info → langflow_base_nightly-0.5.1.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langflow-base-nightly
-Version: 0.5.1.dev3
+Version: 0.5.1.dev5
 Summary: A Python package with a built-in web application
 Project-URL: Repository, https://github.com/langflow-ai/langflow
 Project-URL: Documentation, https://docs.langflow.org
@@ -45,6 +45,7 @@ Requires-Dist: langchain-experimental<1.0.0,>=0.3.4
 Requires-Dist: langchain-ibm>=0.3.8
 Requires-Dist: langchainhub~=0.1.15
 Requires-Dist: langchain~=0.3.21
+Requires-Dist: lfx-nightly==0.1.11.dev1
 Requires-Dist: loguru<1.0.0,>=0.7.1
 Requires-Dist: mcp~=1.10.1
 Requires-Dist: multiprocess<1.0.0,>=0.70.14