langflow-base-nightly 0.5.0.dev37__py3-none-any.whl → 0.5.0.dev39__py3-none-any.whl

langflow/interface/components.py

@@ -7,9 +7,8 @@ import pkgutil
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from loguru import logger
-
 from langflow.custom.utils import abuild_custom_components, create_component_template
+from langflow.logging.logger import logger
 from langflow.services.settings.base import BASE_COMPONENTS_PATH
 
 if TYPE_CHECKING:
@@ -49,7 +48,7 @@ async def import_langflow_components():
     try:
         import langflow.components as components_pkg
     except ImportError as e:
-        logger.error(f"Failed to import langflow.components package: {e}", exc_info=True)
+        await logger.aerror(f"Failed to import langflow.components package: {e}", exc_info=True)
         return {"components": modules_dict}
 
     # Collect all module names to process
@@ -69,13 +68,13 @@ async def import_langflow_components():
     try:
         module_results = await asyncio.gather(*tasks, return_exceptions=True)
     except Exception as e:  # noqa: BLE001
-        logger.error(f"Error during parallel module processing: {e}", exc_info=True)
+        await logger.aerror(f"Error during parallel module processing: {e}", exc_info=True)
         return {"components": modules_dict}
 
     # Merge results from all modules
     for result in module_results:
         if isinstance(result, Exception):
-            logger.warning(f"Module processing failed: {result}")
+            await logger.awarning(f"Module processing failed: {result}")
             continue
 
         if result and isinstance(result, tuple) and len(result) == EXPECTED_RESULT_LENGTH:
@@ -165,7 +164,7 @@ async def _determine_loading_strategy(settings_service: SettingsService) -> dict
     component_cache.all_types_dict = {}
     if settings_service.settings.lazy_load_components:
         # Partial loading mode - just load component metadata
-        logger.debug("Using partial component loading")
+        await logger.adebug("Using partial component loading")
         component_cache.all_types_dict = await aget_component_metadata(settings_service.settings.components_path)
     elif settings_service.settings.components_path:
         # Traditional full loading - filter out base components path to only load custom components
@@ -177,7 +176,9 @@ async def _determine_loading_strategy(settings_service: SettingsService) -> dict
     components_dict = component_cache.all_types_dict or {}
     component_count = sum(len(comps) for comps in components_dict.get("components", {}).values())
     if component_count > 0 and settings_service.settings.components_path:
-        logger.debug(f"Built {component_count} custom components from {settings_service.settings.components_path}")
+        await logger.adebug(
+            f"Built {component_count} custom components from {settings_service.settings.components_path}"
+        )
 
     return component_cache.all_types_dict
 
@@ -193,7 +194,7 @@ async def get_and_cache_all_types_dict(
     resulting dictionary.
     """
     if component_cache.all_types_dict is None:
-        logger.debug("Building components cache")
+        await logger.adebug("Building components cache")
 
         langflow_components = await import_langflow_components()
         custom_components_dict = await _determine_loading_strategy(settings_service)
@@ -204,7 +205,7 @@ async def get_and_cache_all_types_dict(
             **custom_components_dict,
         }
         component_count = sum(len(comps) for comps in component_cache.all_types_dict.values())
-        logger.debug(f"Loaded {component_count} components")
+        await logger.adebug(f"Loaded {component_count} components")
     return component_cache.all_types_dict
 
 
@@ -235,7 +236,7 @@ async def aget_component_metadata(components_paths: list[str]):
 
     # Get all component types
     component_types = await discover_component_types(components_paths)
-    logger.debug(f"Discovered {len(component_types)} component types: {', '.join(component_types)}")
+    await logger.adebug(f"Discovered {len(component_types)} component types: {', '.join(component_types)}")
 
     # For each component type directory
     for component_type in component_types:
@@ -243,7 +244,7 @@ async def aget_component_metadata(components_paths: list[str]):
 
         # Get list of components in this type
         component_names = await discover_component_names(component_type, components_paths)
-        logger.debug(f"Found {len(component_names)} components for type {component_type}")
+        await logger.adebug(f"Found {len(component_names)} components for type {component_type}")
 
         # Create stub entries with just basic metadata
         for name in component_names:
@@ -365,7 +366,7 @@ async def ensure_component_loaded(component_type: str, component_name: str, sett
 
     # Check if component is marked for lazy loading
     if component_cache.all_types_dict["components"][component_type][component_name].get("lazy_loaded", False):
-        logger.debug(f"Fully loading component {component_type}:{component_name}")
+        await logger.adebug(f"Fully loading component {component_type}:{component_name}")
 
         # Load just this specific component
         full_component = await load_single_component(
@@ -381,9 +382,9 @@ async def ensure_component_loaded(component_type: str, component_name: str, sett
 
             # Mark as fully loaded
             component_cache.fully_loaded_components[component_key] = True
-            logger.debug(f"Component {component_type}:{component_name} fully loaded")
+            await logger.adebug(f"Component {component_type}:{component_name} fully loaded")
         else:
-            logger.warning(f"Failed to fully load component {component_type}:{component_name}")
+            await logger.awarning(f"Failed to fully load component {component_type}:{component_name}")
 
 
 async def load_single_component(component_type: str, component_name: str, components_paths: list[str]):
@@ -396,32 +397,32 @@ async def load_single_component(component_type: str, component_name: str, compon
         return await get_single_component_dict(component_type, component_name, components_paths)
     except (ImportError, ModuleNotFoundError) as e:
         # Handle issues with importing the component or its dependencies
-        logger.error(f"Import error loading component {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"Import error loading component {component_type}:{component_name}: {e!s}")
         return None
     except (AttributeError, TypeError) as e:
         # Handle issues with component structure or type errors
-        logger.error(f"Component structure error for {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"Component structure error for {component_type}:{component_name}: {e!s}")
         return None
     except FileNotFoundError as e:
         # Handle missing files
-        logger.error(f"File not found for component {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"File not found for component {component_type}:{component_name}: {e!s}")
         return None
     except ValueError as e:
         # Handle invalid values or configurations
-        logger.error(f"Invalid configuration for component {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"Invalid configuration for component {component_type}:{component_name}: {e!s}")
         return None
     except (KeyError, IndexError) as e:
         # Handle data structure access errors
-        logger.error(f"Data structure error for component {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"Data structure error for component {component_type}:{component_name}: {e!s}")
         return None
     except RuntimeError as e:
         # Handle runtime errors
-        logger.error(f"Runtime error loading component {component_type}:{component_name}: {e!s}")
-        logger.debug("Full traceback for runtime error", exc_info=True)
+        await logger.aerror(f"Runtime error loading component {component_type}:{component_name}: {e!s}")
+        await logger.adebug("Full traceback for runtime error", exc_info=True)
         return None
     except OSError as e:
         # Handle OS-related errors (file system, permissions, etc.)
-        logger.error(f"OS error loading component {component_type}:{component_name}: {e!s}")
+        await logger.aerror(f"OS error loading component {component_type}:{component_name}: {e!s}")
         return None
 
 

langflow/interface/initialize/loading.py

@@ -6,10 +6,10 @@ import warnings
 from typing import TYPE_CHECKING, Any
 
 import orjson
-from loguru import logger
 from pydantic import PydanticDeprecatedSince20
 
 from langflow.custom.eval import eval_custom_component_code
+from langflow.logging.logger import logger
 from langflow.schema.artifact import get_artifact_type, post_process_raw
 from langflow.schema.data import Data
 from langflow.services.deps import get_tracing_service, session_scope
@@ -126,19 +126,19 @@ async def update_params_with_load_from_db_fields(
                     raise
                 if "variable not found." in str(e) and not fallback_to_env_vars:
                     raise
-                logger.debug(str(e))
+                await logger.adebug(str(e))
                 key = None
 
             if fallback_to_env_vars and key is None:
                 key = os.getenv(params[field])
                 if key:
-                    logger.info(f"Using environment variable {params[field]} for {field}")
+                    await logger.ainfo(f"Using environment variable {params[field]} for {field}")
                 else:
-                    logger.error(f"Environment variable {params[field]} is not set.")
+                    await logger.aerror(f"Environment variable {params[field]} is not set.")
 
             params[field] = key if key is not None else None
             if key is None:
-                logger.warning(f"Could not get value for {field}. Setting it to None.")
+                await logger.awarning(f"Could not get value for {field}. Setting it to None.")
 
         return params
 

langflow/interface/run.py

@@ -1,4 +1,4 @@
-from loguru import logger
+from langflow.logging.logger import logger
 
 
 def get_memory_key(langchain_object):

langflow/interface/utils.py

@@ -7,9 +7,9 @@ from string import Formatter
 
 import yaml
 from langchain_core.language_models import BaseLanguageModel
-from loguru import logger
 from PIL.Image import Image
 
+from langflow.logging.logger import logger
 from langflow.services.chat.config import ChatConfig
 from langflow.services.deps import get_settings_service
 

langflow/io/__init__.py

@@ -1,4 +1,3 @@
-# noqa: A005
 from langflow.inputs import (
     BoolInput,
     CodeInput,

langflow/langflow_launcher.py

@@ -44,7 +44,7 @@ def _launch_with_exec():
     os.environ["no_proxy"] = "*"
 
     try:
-        os.execv(sys.executable, [sys.executable, "-m", "langflow.__main__"] + sys.argv[1:])  # noqa: S606
+        os.execv(sys.executable, [sys.executable, "-m", "langflow.__main__", *sys.argv[1:]])  # noqa: S606
     except OSError as e:
         # If exec fails, we need to exit since the process replacement failed
         typer.echo(f"Failed to exec langflow: {e}", file=sys.stderr)

langflow/load/load.py

@@ -4,7 +4,6 @@ from pathlib import Path
 
 from aiofile import async_open
 from dotenv import dotenv_values
-from loguru import logger
 
 from langflow.graph.graph.base import Graph
 from langflow.graph.schema import RunOutputs
@@ -49,9 +48,7 @@ async def aload_flow_from_json(
     """
     # 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, async_file=True, log_rotation=log_rotation
-    )
+    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:
@@ -179,7 +176,7 @@ async def arun_flow_from_json(
         cache=cache,
         disable_logs=disable_logs,
     )
-    result = await run_graph(
+    return await run_graph(
         graph=graph,
         session_id=session_id,
         input_value=input_value,
@@ -188,8 +185,6 @@ async def arun_flow_from_json(
         output_component=output_component,
         fallback_to_env_vars=fallback_to_env_vars,
     )
-    await logger.complete()
-    return result
 
 
 def run_flow_from_json(

langflow/logging/__init__.py

@@ -1,4 +1,3 @@
-# noqa: A005
 from .logger import configure, logger
 from .setup import disable_logging, enable_logging