langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/load/load.py

@@ -1,250 +0,0 @@
-import json
-from io import StringIO
-from pathlib import Path
-
-from aiofile import async_open
-from dotenv import dotenv_values
-
-from langflow.graph.graph.base import Graph
-from langflow.graph.schema import RunOutputs
-from langflow.load.utils import replace_tweaks_with_env
-from langflow.logging.logger import configure
-from langflow.processing.process import process_tweaks, run_graph
-from langflow.utils.async_helpers import run_until_complete
-from langflow.utils.util import update_settings
-
-
-async def aload_flow_from_json(
-    flow: Path | str | dict,
-    *,
-    tweaks: dict | None = None,
-    log_level: str | None = None,
-    log_file: str | None = None,
-    log_rotation: str | None = None,
-    env_file: str | None = None,
-    cache: str | None = None,
-    disable_logs: bool | None = True,
-) -> Graph:
-    """Load a flow graph from a JSON file or a JSON object.
-
-    Args:
-        flow (Union[Path, str, dict]): The flow to load. It can be a file path (str or Path object)
-            or a JSON object (dict).
-        tweaks (Optional[dict]): Optional tweaks to apply to the loaded flow graph.
-        log_level (Optional[str]): Optional log level to configure for the flow processing.
-        log_file (Optional[str]): Optional log file to configure for the flow processing.
-        log_rotation (Optional[str]): Optional log rotation(Time/Size) to configure for the flow processing.
-        env_file (Optional[str]): Optional .env file to override environment variables.
-        cache (Optional[str]): Optional cache path to update the flow settings.
-        disable_logs (Optional[bool], default=True): Optional flag to disable logs during flow processing.
-            If log_level or log_file are set, disable_logs is not used.
-
-    Returns:
-        Graph: The loaded flow graph as a Graph object.
-
-    Raises:
-        TypeError: If the input is neither a file path (str or Path object) nor a JSON object (dict).
-
-    """
-    # If input is a file path, load JSON from the file
-    log_file_path = Path(log_file) if log_file else None
-    configure(log_level=log_level, log_file=log_file_path, disable=disable_logs, log_rotation=log_rotation)
-
-    # override env variables with .env file
-    if env_file and tweaks is not None:
-        async with async_open(Path(env_file), encoding="utf-8") as f:
-            content = await f.read()
-            env_vars = dotenv_values(stream=StringIO(content))
-        tweaks = replace_tweaks_with_env(tweaks=tweaks, env_vars=env_vars)
-
-    # Update settings with cache and components path
-    await update_settings(cache=cache)
-
-    if isinstance(flow, str | Path):
-        async with async_open(Path(flow), encoding="utf-8") as f:
-            content = await f.read()
-            flow_graph = json.loads(content)
-    # If input is a dictionary, assume it's a JSON object
-    elif isinstance(flow, dict):
-        flow_graph = flow
-    else:
-        msg = "Input must be either a file path (str) or a JSON object (dict)"
-        raise TypeError(msg)
-
-    graph_data = flow_graph["data"]
-    if tweaks is not None:
-        graph_data = process_tweaks(graph_data, tweaks)
-
-    return Graph.from_payload(graph_data)
-
-
-def load_flow_from_json(
-    flow: Path | str | dict,
-    *,
-    tweaks: dict | None = None,
-    log_level: str | None = None,
-    log_file: str | None = None,
-    log_rotation: str | None = None,
-    env_file: str | None = None,
-    cache: str | None = None,
-    disable_logs: bool | None = True,
-) -> Graph:
-    """Load a flow graph from a JSON file or a JSON object.
-
-    Args:
-        flow (Union[Path, str, dict]): The flow to load. It can be a file path (str or Path object)
-            or a JSON object (dict).
-        tweaks (Optional[dict]): Optional tweaks to apply to the loaded flow graph.
-        log_level (Optional[str]): Optional log level to configure for the flow processing.
-        log_file (Optional[str]): Optional log file to configure for the flow processing.
-        log_rotation (Optional[str]): Optional log rotation(Time/Size) to configure for the flow processing.
-        env_file (Optional[str]): Optional .env file to override environment variables.
-        cache (Optional[str]): Optional cache path to update the flow settings.
-        disable_logs (Optional[bool], default=True): Optional flag to disable logs during flow processing.
-            If log_level or log_file are set, disable_logs is not used.
-
-    Returns:
-        Graph: The loaded flow graph as a Graph object.
-
-    Raises:
-        TypeError: If the input is neither a file path (str or Path object) nor a JSON object (dict).
-
-    """
-    return run_until_complete(
-        aload_flow_from_json(
-            flow,
-            tweaks=tweaks,
-            log_level=log_level,
-            log_file=log_file,
-            log_rotation=log_rotation,
-            env_file=env_file,
-            cache=cache,
-            disable_logs=disable_logs,
-        )
-    )
-
-
-async def arun_flow_from_json(
-    flow: Path | str | dict,
-    input_value: str,
-    *,
-    session_id: str | None = None,
-    tweaks: dict | None = None,
-    input_type: str = "chat",
-    output_type: str = "chat",
-    output_component: str | None = None,
-    log_level: str | None = None,
-    log_file: str | None = None,
-    log_rotation: str | None = None,
-    env_file: str | None = None,
-    cache: str | None = None,
-    disable_logs: bool | None = True,
-    fallback_to_env_vars: bool = False,
-) -> list[RunOutputs]:
-    """Run a flow from a JSON file or dictionary.
-
-    Args:
-        flow (Union[Path, str, dict]): The path to the JSON file or the JSON dictionary representing the flow.
-        input_value (str): The input value to be processed by the flow.
-        session_id (str | None, optional): The session ID to be used for the flow. Defaults to None.
-        tweaks (Optional[dict], optional): Optional tweaks to be applied to the flow. Defaults to None.
-        input_type (str, optional): The type of the input value. Defaults to "chat".
-        output_type (str, optional): The type of the output value. Defaults to "chat".
-        output_component (Optional[str], optional): The specific component to output. Defaults to None.
-        log_level (Optional[str], optional): The log level to use. Defaults to None.
-        log_file (Optional[str], optional): The log file to write logs to. Defaults to None.
-        log_rotation (Optional[str], optional): The log rotation to use. Defaults to None.
-        env_file (Optional[str], optional): The environment file to load. Defaults to None.
-        cache (Optional[str], optional): The cache directory to use. Defaults to None.
-        disable_logs (Optional[bool], optional): Whether to disable logs. Defaults to True.
-        fallback_to_env_vars (bool, optional): Whether Global Variables should fallback to environment variables if
-            not found. Defaults to False.
-
-    Returns:
-        List[RunOutputs]: A list of RunOutputs objects representing the results of running the flow.
-    """
-    if tweaks is None:
-        tweaks = {}
-    tweaks["stream"] = False
-    graph = await aload_flow_from_json(
-        flow=flow,
-        tweaks=tweaks,
-        log_level=log_level,
-        log_file=log_file,
-        log_rotation=log_rotation,
-        env_file=env_file,
-        cache=cache,
-        disable_logs=disable_logs,
-    )
-    return await run_graph(
-        graph=graph,
-        session_id=session_id,
-        input_value=input_value,
-        input_type=input_type,
-        output_type=output_type,
-        output_component=output_component,
-        fallback_to_env_vars=fallback_to_env_vars,
-    )
-
-
-def run_flow_from_json(
-    flow: Path | str | dict,
-    input_value: str,
-    *,
-    session_id: str | None = None,
-    tweaks: dict | None = None,
-    input_type: str = "chat",
-    output_type: str = "chat",
-    output_component: str | None = None,
-    log_level: str | None = None,
-    log_file: str | None = None,
-    log_rotation: str | None = None,
-    env_file: str | None = None,
-    cache: str | None = None,
-    disable_logs: bool | None = True,
-    fallback_to_env_vars: bool = False,
-) -> list[RunOutputs]:
-    """Run a flow from a JSON file or dictionary.
-
-    Note:
-        This function is a synchronous wrapper around `arun_flow_from_json`.
-        It creates an event loop if one does not exist and runs the flow.
-
-    Args:
-        flow (Union[Path, str, dict]): The path to the JSON file or the JSON dictionary representing the flow.
-        input_value (str): The input value to be processed by the flow.
-        session_id (str | None, optional): The session ID to be used for the flow. Defaults to None.
-        tweaks (Optional[dict], optional): Optional tweaks to be applied to the flow. Defaults to None.
-        input_type (str, optional): The type of the input value. Defaults to "chat".
-        output_type (str, optional): The type of the output value. Defaults to "chat".
-        output_component (Optional[str], optional): The specific component to output. Defaults to None.
-        log_level (Optional[str], optional): The log level to use. Defaults to None.
-        log_file (Optional[str], optional): The log file to write logs to. Defaults to None.
-        log_rotation (Optional[str], optional): The log rotation to use. Defaults to None.
-        env_file (Optional[str], optional): The environment file to load. Defaults to None.
-        cache (Optional[str], optional): The cache directory to use. Defaults to None.
-        disable_logs (Optional[bool], optional): Whether to disable logs. Defaults to True.
-        fallback_to_env_vars (bool, optional): Whether Global Variables should fallback to environment variables if
-            not found. Defaults to False.
-
-    Returns:
-        List[RunOutputs]: A list of RunOutputs objects representing the results of running the flow.
-    """
-    return run_until_complete(
-        arun_flow_from_json(
-            flow,
-            input_value,
-            session_id=session_id,
-            tweaks=tweaks,
-            input_type=input_type,
-            output_type=output_type,
-            output_component=output_component,
-            log_level=log_level,
-            log_file=log_file,
-            log_rotation=log_rotation,
-            env_file=env_file,
-            cache=cache,
-            disable_logs=disable_logs,
-            fallback_to_env_vars=fallback_to_env_vars,
-        )
-    )

langflow/logging/logger.py

@@ -1,369 +0,0 @@
-"""Logging configuration for Langflow using structlog."""
-
-import json
-import logging
-import logging.handlers
-import os
-import sys
-from collections import deque
-from datetime import datetime
-from pathlib import Path
-from threading import Lock, Semaphore
-from typing import Any, TypedDict
-
-import orjson
-import structlog
-from platformdirs import user_cache_dir
-from typing_extensions import NotRequired
-
-from langflow.settings import DEV
-
-VALID_LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-
-# Map log level names to integers
-LOG_LEVEL_MAP = {
-    "DEBUG": logging.DEBUG,
-    "INFO": logging.INFO,
-    "WARNING": logging.WARNING,
-    "ERROR": logging.ERROR,
-    "CRITICAL": logging.CRITICAL,
-}
-
-
-class SizedLogBuffer:
-    """A buffer for storing log messages for the log retrieval API."""
-
-    def __init__(
-        self,
-        max_readers: int = 20,  # max number of concurrent readers for the buffer
-    ):
-        """Initialize the buffer.
-
-        The buffer can be overwritten by an env variable LANGFLOW_LOG_RETRIEVER_BUFFER_SIZE
-        because the logger is initialized before the settings_service are loaded.
-        """
-        self.buffer: deque = deque()
-
-        self._max_readers = max_readers
-        self._wlock = Lock()
-        self._rsemaphore = Semaphore(max_readers)
-        self._max = 0
-
-    def get_write_lock(self) -> Lock:
-        """Get the write lock."""
-        return self._wlock
-
-    def write(self, message: str) -> None:
-        """Write a message to the buffer."""
-        record = json.loads(message)
-        log_entry = record.get("event", record.get("msg", record.get("text", "")))
-
-        # Extract timestamp - support both direct timestamp and nested record.time.timestamp
-        timestamp = record.get("timestamp", 0)
-        if timestamp == 0 and "record" in record:
-            # Support nested structure from tests: record.time.timestamp
-            time_info = record["record"].get("time", {})
-            timestamp = time_info.get("timestamp", 0)
-
-        if isinstance(timestamp, str):
-            # Parse ISO format timestamp
-            dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
-            epoch = int(dt.timestamp() * 1000)
-        else:
-            epoch = int(timestamp * 1000)
-
-        with self._wlock:
-            if len(self.buffer) >= self.max:
-                for _ in range(len(self.buffer) - self.max + 1):
-                    self.buffer.popleft()
-            self.buffer.append((epoch, log_entry))
-
-    def __len__(self) -> int:
-        """Get the length of the buffer."""
-        return len(self.buffer)
-
-    def get_after_timestamp(self, timestamp: int, lines: int = 5) -> dict[int, str]:
-        """Get log entries after a timestamp."""
-        rc = {}
-
-        self._rsemaphore.acquire()
-        try:
-            with self._wlock:
-                for ts, msg in self.buffer:
-                    if lines == 0:
-                        break
-                    if ts >= timestamp and lines > 0:
-                        rc[ts] = msg
-                        lines -= 1
-        finally:
-            self._rsemaphore.release()
-
-        return rc
-
-    def get_before_timestamp(self, timestamp: int, lines: int = 5) -> dict[int, str]:
-        """Get log entries before a timestamp."""
-        self._rsemaphore.acquire()
-        try:
-            with self._wlock:
-                as_list = list(self.buffer)
-            max_index = -1
-            for i, (ts, _) in enumerate(as_list):
-                if ts >= timestamp:
-                    max_index = i
-                    break
-            if max_index == -1:
-                return self.get_last_n(lines)
-            rc = {}
-            start_from = max(max_index - lines, 0)
-            for i, (ts, msg) in enumerate(as_list):
-                if start_from <= i < max_index:
-                    rc[ts] = msg
-            return rc
-        finally:
-            self._rsemaphore.release()
-
-    def get_last_n(self, last_idx: int) -> dict[int, str]:
-        """Get the last n log entries."""
-        self._rsemaphore.acquire()
-        try:
-            with self._wlock:
-                as_list = list(self.buffer)
-            return dict(as_list[-last_idx:])
-        finally:
-            self._rsemaphore.release()
-
-    @property
-    def max(self) -> int:
-        """Get the maximum buffer size."""
-        # Get it dynamically to allow for env variable changes
-        if self._max == 0:
-            env_buffer_size = os.getenv("LANGFLOW_LOG_RETRIEVER_BUFFER_SIZE", "0")
-            if env_buffer_size.isdigit():
-                self._max = int(env_buffer_size)
-        return self._max
-
-    @max.setter
-    def max(self, value: int) -> None:
-        """Set the maximum buffer size."""
-        self._max = value
-
-    def enabled(self) -> bool:
-        """Check if the buffer is enabled."""
-        return self.max > 0
-
-    def max_size(self) -> int:
-        """Get the maximum buffer size."""
-        return self.max
-
-
-# log buffer for capturing log messages
-log_buffer = SizedLogBuffer()
-
-
-def add_serialized(_logger: Any, _method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
-    """Add serialized version of the log entry."""
-    # Only add serialized if we're in JSON mode (for log buffer)
-    if log_buffer.enabled():
-        subset = {
-            "timestamp": event_dict.get("timestamp", 0),
-            "message": event_dict.get("event", ""),
-            "level": _method_name.upper(),
-            "module": event_dict.get("module", ""),
-        }
-        event_dict["serialized"] = orjson.dumps(subset)
-    return event_dict
-
-
-def remove_exception_in_production(_logger: Any, _method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
-    """Remove exception details in production."""
-    if DEV is False:
-        event_dict.pop("exception", None)
-        event_dict.pop("exc_info", None)
-    return event_dict
-
-
-def buffer_writer(_logger: Any, _method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
-    """Write to log buffer if enabled."""
-    if log_buffer.enabled():
-        # Create a JSON representation for the buffer
-        log_buffer.write(json.dumps(event_dict))
-    return event_dict
-
-
-class LogConfig(TypedDict):
-    """Configuration for logging."""
-
-    log_level: NotRequired[str]
-    log_file: NotRequired[Path]
-    disable: NotRequired[bool]
-    log_env: NotRequired[str]
-    log_format: NotRequired[str]
-
-
-def configure(
-    *,
-    log_level: str | None = None,
-    log_file: Path | None = None,
-    disable: bool | None = False,
-    log_env: str | None = None,
-    log_format: str | None = None,
-    log_rotation: str | None = None,
-) -> None:
-    """Configure the logger."""
-    if os.getenv("LANGFLOW_LOG_LEVEL", "").upper() in VALID_LOG_LEVELS and log_level is None:
-        log_level = os.getenv("LANGFLOW_LOG_LEVEL")
-    if log_level is None:
-        log_level = "ERROR"
-
-    if log_file is None:
-        env_log_file = os.getenv("LANGFLOW_LOG_FILE", "")
-        log_file = Path(env_log_file) if env_log_file else None
-
-    if log_env is None:
-        log_env = os.getenv("LANGFLOW_LOG_ENV", "")
-
-    # Get log format from env if not provided
-    if log_format is None:
-        log_format = os.getenv("LANGFLOW_LOG_FORMAT")
-
-    # Configure processors based on environment
-    processors = [
-        structlog.contextvars.merge_contextvars,
-        structlog.processors.add_log_level,
-        structlog.processors.TimeStamper(fmt="iso"),
-        add_serialized,
-        remove_exception_in_production,
-        buffer_writer,
-    ]
-
-    # Configure output based on environment
-    if log_env.lower() == "container" or log_env.lower() == "container_json":
-        processors.append(structlog.processors.JSONRenderer())
-    elif log_env.lower() == "container_csv":
-        processors.append(
-            structlog.processors.KeyValueRenderer(
-                key_order=["timestamp", "level", "module", "event"], drop_missing=True
-            )
-        )
-    else:
-        # Use rich console for pretty printing based on environment variable
-        log_stdout_pretty = os.getenv("LANGFLOW_PRETTY_LOGS", "true").lower() == "true"
-        if log_stdout_pretty:
-            # If custom format is provided, use KeyValueRenderer with custom format
-            if log_format:
-                processors.append(structlog.processors.KeyValueRenderer())
-            else:
-                processors.append(structlog.dev.ConsoleRenderer(colors=True))
-        else:
-            processors.append(structlog.processors.JSONRenderer())
-
-    # Get numeric log level
-    numeric_level = LOG_LEVEL_MAP.get(log_level.upper(), logging.ERROR)
-
-    # Configure structlog
-    structlog.configure(
-        processors=processors,
-        wrapper_class=structlog.make_filtering_bound_logger(numeric_level),
-        context_class=dict,
-        logger_factory=structlog.PrintLoggerFactory(file=sys.stdout)
-        if not log_file
-        else structlog.stdlib.LoggerFactory(),
-        cache_logger_on_first_use=True,
-    )
-
-    # Set up file logging if needed
-    if log_file:
-        if not log_file.parent.exists():
-            cache_dir = Path(user_cache_dir("langflow"))
-            log_file = cache_dir / "langflow.log"
-
-        # Parse rotation settings
-        if log_rotation:
-            # Handle rotation like "1 day", "100 MB", etc.
-            max_bytes = 10 * 1024 * 1024  # Default 10MB
-            if "MB" in log_rotation.upper():
-                try:
-                    # Look for pattern like "100 MB" (with space)
-                    parts = log_rotation.split()
-                    expected_parts = 2
-                    if len(parts) >= expected_parts and parts[1].upper() == "MB":
-                        mb = int(parts[0])
-                        if mb > 0:  # Only use valid positive values
-                            max_bytes = mb * 1024 * 1024
-                except (ValueError, IndexError):
-                    pass
-        else:
-            max_bytes = 10 * 1024 * 1024  # Default 10MB
-
-        # Since structlog doesn't have built-in rotation, we'll use stdlib logging for file output
-        file_handler = logging.handlers.RotatingFileHandler(
-            log_file,
-            maxBytes=max_bytes,
-            backupCount=5,
-        )
-        file_handler.setFormatter(logging.Formatter("%(message)s"))
-
-        # Add file handler to root logger
-        logging.root.addHandler(file_handler)
-        logging.root.setLevel(numeric_level)
-
-    # Set up interceptors for uvicorn and gunicorn
-    setup_uvicorn_logger()
-    setup_gunicorn_logger()
-
-    # Create the global logger instance
-    global logger  # noqa: PLW0603
-    logger = structlog.get_logger()
-
-    if disable:
-        # In structlog, we can set a very high filter level to effectively disable logging
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.CRITICAL),
-        )
-
-    logger.debug("Logger set up with log level: %s", log_level)
-
-
-def setup_uvicorn_logger() -> None:
-    """Redirect uvicorn logs through structlog."""
-    loggers = (logging.getLogger(name) for name in logging.root.manager.loggerDict if name.startswith("uvicorn."))
-    for uvicorn_logger in loggers:
-        uvicorn_logger.handlers = []
-        uvicorn_logger.propagate = True
-
-
-def setup_gunicorn_logger() -> None:
-    """Redirect gunicorn logs through structlog."""
-    logging.getLogger("gunicorn.error").handlers = []
-    logging.getLogger("gunicorn.error").propagate = True
-    logging.getLogger("gunicorn.access").handlers = []
-    logging.getLogger("gunicorn.access").propagate = True
-
-
-class InterceptHandler(logging.Handler):
-    """Intercept standard logging messages and route them to structlog."""
-
-    def emit(self, record: logging.LogRecord) -> None:
-        """Emit a log record by passing it to structlog."""
-        # Get corresponding structlog logger
-        logger_name = record.name
-        structlog_logger = structlog.get_logger(logger_name)
-
-        # Map log levels
-        level = record.levelno
-        if level >= logging.CRITICAL:
-            structlog_logger.critical(record.getMessage())
-        elif level >= logging.ERROR:
-            structlog_logger.error(record.getMessage())
-        elif level >= logging.WARNING:
-            structlog_logger.warning(record.getMessage())
-        elif level >= logging.INFO:
-            structlog_logger.info(record.getMessage())
-        else:
-            structlog_logger.debug(record.getMessage())
-
-
-# Initialize logger - will be reconfigured when configure() is called
-# Set it to critical level
-logger: structlog.BoundLogger = structlog.get_logger()
-configure(log_level="CRITICAL", disable=True)

langflow/processing/utils.py

@@ -1,25 +0,0 @@
-import json
-from typing import Any
-
-from json_repair import repair_json
-
-
-def validate_and_repair_json(json_str: str | dict) -> dict[str, Any] | str:
-    """Validates a JSON string and attempts to repair it if invalid.
-
-    Args:
-        json_str (str): The JSON string to validate/repair
-
-    Returns:
-        Union[Dict[str, Any], str]: The parsed JSON dict if valid/repairable,
-        otherwise returns the original string
-    """
-    if not isinstance(json_str, str):
-        return json_str
-    try:
-        # If invalid, attempt repair
-        repaired = repair_json(json_str)
-        return json.loads(repaired)
-    except (json.JSONDecodeError, ImportError):
-        # Return original if repair fails or module not found
-        return json_str