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

langflow/template/frontend_node/custom_components.py

@@ -1,97 +0,0 @@
-from langflow.template.field.base import Input
-from langflow.template.frontend_node.base import FrontendNode
-from langflow.template.template.base import Template
-
-DEFAULT_CUSTOM_COMPONENT_CODE = """from langflow.custom import CustomComponent
-
-from typing import Optional, List, Dict, Union
-from langflow.field_typing import (
-    AgentExecutor,
-    BaseChatMemory,
-    BaseLanguageModel,
-    BaseLLM,
-    BaseLoader,
-    BaseMemory,
-    BasePromptTemplate,
-    BaseRetriever,
-    Callable,
-    Chain,
-    ChatPromptTemplate,
-    Data,
-    Document,
-    Embeddings,
-    NestedDict,
-    Object,
-    PromptTemplate,
-    TextSplitter,
-    Tool,
-    VectorStore,
-)
-
-
-class Component(CustomComponent):
-    display_name: str = "Custom Component"
-    description: str = "Create any custom component you want!"
-
-    def build_config(self):
-        return {"param": {"display_name": "Parameter"}}
-
-    def build(self, param: Data) -> Data:
-        return param
-
-"""
-
-
-class CustomComponentFrontendNode(FrontendNode):
-    _format_template: bool = False
-    name: str = "CustomComponent"
-    display_name: str | None = "CustomComponent"
-    beta: bool = False
-    legacy: bool = False
-    minimized: bool = False
-    template: Template = Template(
-        type_name="CustomComponent",
-        fields=[
-            Input(
-                field_type="code",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                value=DEFAULT_CUSTOM_COMPONENT_CODE,
-                name="code",
-                advanced=False,
-                dynamic=True,
-            )
-        ],
-    )
-    description: str | None = None
-    base_classes: list[str] = []
-    last_updated: str | None = None
-
-
-class ComponentFrontendNode(FrontendNode):
-    _format_template: bool = False
-    name: str = "Component"
-    display_name: str | None = "Component"
-    beta: bool = False
-    minimized: bool = False
-    legacy: bool = False
-    template: Template = Template(
-        type_name="Component",
-        fields=[
-            Input(
-                field_type="code",
-                required=True,
-                placeholder="",
-                is_list=False,
-                show=True,
-                value=DEFAULT_CUSTOM_COMPONENT_CODE,
-                name="code",
-                advanced=False,
-                dynamic=True,
-            )
-        ],
-    )
-    description: str | None = None
-    base_classes: list[str] = []

langflow/template/template/base.py

@@ -1,99 +0,0 @@
-from collections.abc import Callable
-from typing import cast
-
-from pydantic import BaseModel, Field, model_serializer
-
-from langflow.inputs.inputs import InputTypes
-from langflow.inputs.utils import instantiate_input
-from langflow.template.field.base import Input
-from langflow.utils.constants import DIRECT_TYPES
-
-
-class Template(BaseModel):
-    type_name: str = Field(serialization_alias="_type")
-    fields: list[InputTypes]
-
-    def process_fields(
-        self,
-        format_field_func: Callable | None = None,
-    ) -> None:
-        if format_field_func:
-            for field in self.fields:
-                format_field_func(field, self.type_name)
-
-    def sort_fields(self) -> None:
-        # first sort alphabetically
-        # then sort fields so that fields that have .field_type in DIRECT_TYPES are first
-        self.fields.sort(key=lambda x: x.name or "")
-        self.fields.sort(
-            key=lambda x: x.field_type in DIRECT_TYPES if hasattr(x, "field_type") else False, reverse=False
-        )
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        result = handler(self)
-        for field in self.fields:
-            result[field.name] = field.model_dump(by_alias=True, exclude_none=True)
-
-        return result
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "Template":
-        for key, value in data.copy().items():
-            if key == "_type":
-                data["type_name"] = value
-                del data[key]
-            else:
-                value["name"] = key
-                if "fields" not in data:
-                    data["fields"] = []
-                input_type = value.pop("_input_type", None)
-                if input_type:
-                    try:
-                        input_ = instantiate_input(input_type, value)
-                    except Exception as e:
-                        msg = f"Error instantiating input {input_type}: {e}"
-                        raise ValueError(msg) from e
-                else:
-                    input_ = Input(**value)
-
-                data["fields"].append(input_)
-
-        # Necessary for components with no inputs(?)
-        if "fields" not in data:
-            data["fields"] = []
-
-        return cls(**data)
-
-    # For backwards compatibility
-    def to_dict(self, format_field_func=None):
-        self.process_fields(format_field_func)
-        self.sort_fields()
-        return self.model_dump(by_alias=True, exclude_none=True, exclude={"fields"})
-
-    def add_field(self, field: Input) -> None:
-        self.fields.append(field)
-
-    def get_field(self, field_name: str) -> Input:
-        """Returns the field with the given name."""
-        field = next((field for field in self.fields if field.name == field_name), None)
-        if field is None:
-            msg = f"Field {field_name} not found in template {self.type_name}"
-            raise ValueError(msg)
-        return cast("Input", field)
-
-    def update_field(self, field_name: str, field: Input) -> None:
-        """Updates the field with the given name."""
-        for idx, template_field in enumerate(self.fields):
-            if template_field.name == field_name:
-                self.fields[idx] = field
-                return
-        msg = f"Field {field_name} not found in template {self.type_name}"
-        raise ValueError(msg)
-
-    def upsert_field(self, field_name: str, field: Input) -> None:
-        """Updates the field with the given name or adds it if it doesn't exist."""
-        try:
-            self.update_field(field_name, field)
-        except ValueError:
-            self.add_field(field)

langflow/utils/async_helpers.py

@@ -1,42 +0,0 @@
-import asyncio
-from contextlib import asynccontextmanager
-
-if hasattr(asyncio, "timeout"):
-
-    @asynccontextmanager
-    async def timeout_context(timeout_seconds):
-        with asyncio.timeout(timeout_seconds) as ctx:
-            yield ctx
-
-else:
-
-    @asynccontextmanager
-    async def timeout_context(timeout_seconds):
-        try:
-            yield await asyncio.wait_for(asyncio.Future(), timeout=timeout_seconds)
-        except asyncio.TimeoutError as e:
-            msg = f"Operation timed out after {timeout_seconds} seconds"
-            raise TimeoutError(msg) from e
-
-
-def run_until_complete(coro):
-    try:
-        asyncio.get_running_loop()
-    except RuntimeError:
-        # If there's no event loop, create a new one and run the coroutine
-        return asyncio.run(coro)
-    # If there's already a running event loop, we can't call run_until_complete on it
-    # Instead, we need to run the coroutine in a new thread with a new event loop
-    import concurrent.futures
-
-    def run_in_new_loop():
-        new_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(new_loop)
-        try:
-            return new_loop.run_until_complete(coro)
-        finally:
-            new_loop.close()
-
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        future = executor.submit(run_in_new_loop)
-        return future.result()

langflow/utils/concurrency.py

@@ -1,60 +0,0 @@
-import re
-import threading
-from contextlib import contextmanager
-from pathlib import Path
-
-from filelock import FileLock
-from platformdirs import user_cache_dir
-
-
-class KeyedMemoryLockManager:
-    """A manager for acquiring and releasing memory locks based on a key."""
-
-    def __init__(self) -> None:
-        self.locks: dict[str, threading.Lock] = {}
-        self.global_lock = threading.Lock()
-
-    def _get_lock(self, key: str):
-        with self.global_lock:
-            if key not in self.locks:
-                self.locks[key] = threading.Lock()
-            return self.locks[key]
-
-    @contextmanager
-    def lock(self, key: str):
-        lock = self._get_lock(key)
-        lock.acquire()
-        try:
-            yield
-        finally:
-            lock.release()
-
-
-class KeyedWorkerLockManager:
-    """A manager for acquiring locks between workers based on a key."""
-
-    def __init__(self) -> None:
-        self.locks_dir = Path(user_cache_dir("langflow"), ensure_exists=True) / "worker_locks"
-
-    @staticmethod
-    def _validate_key(key: str) -> bool:
-        """Validate that the string only contains alphanumeric characters and underscores.
-
-        Parameters:
-        s (str): The string to validate.
-
-        Returns:
-        bool: True if the string is valid, False otherwise.
-        """
-        pattern = re.compile(r"^\w+$")
-        return bool(pattern.match(key))
-
-    @contextmanager
-    def lock(self, key: str):
-        if not self._validate_key(key):
-            msg = f"Invalid key: {key}"
-            raise ValueError(msg)
-
-        lock = FileLock(self.locks_dir / key)
-        with lock:
-            yield

langflow/utils/util_strings.py

@@ -1,56 +0,0 @@
-from sqlalchemy.engine import make_url
-
-from langflow.serialization import constants
-
-
-def truncate_long_strings(data, max_length=None):
-    """Recursively traverse the dictionary or list and truncate strings longer than max_length.
-
-    Returns:
-        The data with strings truncated if they exceed the max length.
-    """
-    if max_length is None:
-        max_length = constants.MAX_TEXT_LENGTH
-
-    if max_length < 0:
-        return data
-
-    if not isinstance(data, dict | list):
-        if isinstance(data, str) and len(data) > max_length:
-            return data[:max_length] + "..."
-        return data
-
-    if isinstance(data, dict):
-        for key, value in data.items():
-            if isinstance(value, str) and len(value) > max_length:
-                data[key] = value[:max_length] + "..."
-            elif isinstance(value, (dict | list)):
-                truncate_long_strings(value, max_length)
-    elif isinstance(data, list):
-        for index, item in enumerate(data):
-            if isinstance(item, str) and len(item) > max_length:
-                data[index] = item[:max_length] + "..."
-            elif isinstance(item, (dict | list)):
-                truncate_long_strings(item, max_length)
-
-    return data
-
-
-def is_valid_database_url(url: str) -> bool:
-    """Validate database connection URLs compatible with SQLAlchemy.
-
-    Args:
-        url (str): Database connection URL to validate
-
-    Returns:
-        bool: True if URL is valid, False otherwise
-    """
-    try:
-        parsed_url = make_url(url)
-        parsed_url.get_dialect()
-        parsed_url.get_driver_name()
-
-    except Exception:  # noqa: BLE001
-        return False
-
-    return True