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

langflow/api/v1/chat.py

@@ -6,23 +6,10 @@ import traceback
 import uuid
 from typing import TYPE_CHECKING, Annotated
 
-from fastapi import (
-    APIRouter,
-    BackgroundTasks,
-    Body,
-    Depends,
-    HTTPException,
-    Request,
-    status,
-)
+from fastapi import APIRouter, BackgroundTasks, Body, Depends, HTTPException, Request, status
 from fastapi.responses import StreamingResponse
-from loguru import logger
 
-from langflow.api.build import (
-    cancel_flow_build,
-    get_flow_events_response,
-    start_flow_build,
-)
+from langflow.api.build import cancel_flow_build, get_flow_events_response, start_flow_build
 from langflow.api.limited_background_tasks import LimitVertexBuildBackgroundTasks
 from langflow.api.utils import (
     CurrentActiveUser,
@@ -48,6 +35,7 @@ from langflow.api.v1.schemas import (
 from langflow.exceptions.component import ComponentBuildError
 from langflow.graph.graph.base import Graph
 from langflow.graph.utils import log_vertex_build
+from langflow.logging.logger import logger
 from langflow.schema.schema import OutputValue
 from langflow.services.cache.utils import CacheMiss
 from langflow.services.chat.service import ChatService
@@ -135,7 +123,7 @@ async def retrieve_vertices_order(
         )
         if "stream or streaming set to True" in str(exc):
             raise HTTPException(status_code=400, detail=str(exc)) from exc
-        logger.exception("Error checking build status")
+        await logger.aexception("Error checking build status")
         raise HTTPException(status_code=500, detail=str(exc)) from exc
 
 
@@ -239,17 +227,17 @@ async def cancel_build(
         return CancelFlowResponse(success=False, message="Failed to cancel flow build")
     except asyncio.CancelledError:
         # If CancelledError reaches here, it means the task was not successfully cancelled
-        logger.error(f"Failed to cancel flow build for job_id {job_id} (CancelledError caught)")
+        await logger.aerror(f"Failed to cancel flow build for job_id {job_id} (CancelledError caught)")
         return CancelFlowResponse(success=False, message="Failed to cancel flow build")
     except ValueError as exc:
         # Job not found
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
     except JobQueueNotFoundError as exc:
-        logger.error(f"Job not found: {job_id}. Error: {exc!s}")
+        await logger.aerror(f"Job not found: {job_id}. Error: {exc!s}")
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Job not found: {exc!s}") from exc
     except Exception as exc:
         # Any other unexpected error
-        logger.exception(f"Error cancelling flow build for job_id {job_id}: {exc}")
+        await logger.aexception(f"Error cancelling flow build for job_id {job_id}: {exc}")
         raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc)) from exc
 
 
@@ -297,7 +285,7 @@ async def build_vertex(
         cache = await chat_service.get_cache(flow_id_str)
         if isinstance(cache, CacheMiss):
             # If there's no cache
-            logger.warning(f"No cache found for {flow_id_str}. Building graph starting at {vertex_id}")
+            await logger.awarning(f"No cache found for {flow_id_str}. Building graph starting at {vertex_id}")
             graph = await build_graph_from_db(
                 flow_id=flow_id,
                 session=await anext(get_session()),
@@ -331,7 +319,7 @@ async def build_vertex(
                 tb = exc.formatted_traceback
             else:
                 tb = traceback.format_exc()
-                logger.exception("Error building Component")
+                await logger.aexception("Error building Component")
                 params = format_exception_message(exc)
             message = {"errorMessage": params, "stackTrace": tb}
             valid = False
@@ -408,7 +396,7 @@ async def build_vertex(
                 component_error_message=str(exc),
             ),
         )
-        logger.exception("Error building Component")
+        await logger.aexception("Error building Component")
         message = parse_exception(exc)
         raise HTTPException(status_code=500, detail=message) from exc
 
@@ -421,14 +409,14 @@ async def _stream_vertex(flow_id: str, vertex_id: str, chat_service: ChatService
         try:
             cache = await chat_service.get_cache(flow_id)
         except Exception as exc:  # noqa: BLE001
-            logger.exception("Error building Component")
+            await logger.aexception("Error building Component")
             yield str(StreamData(event="error", data={"error": str(exc)}))
             return
 
         if isinstance(cache, CacheMiss):
             # If there's no cache
             msg = f"No cache found for {flow_id}."
-            logger.error(msg)
+            await logger.aerror(msg)
             yield str(StreamData(event="error", data={"error": msg}))
             return
         else:
@@ -437,13 +425,13 @@ async def _stream_vertex(flow_id: str, vertex_id: str, chat_service: ChatService
         try:
             vertex: InterfaceVertex = graph.get_vertex(vertex_id)
         except Exception as exc:  # noqa: BLE001
-            logger.exception("Error building Component")
+            await logger.aexception("Error building Component")
             yield str(StreamData(event="error", data={"error": str(exc)}))
             return
 
         if not hasattr(vertex, "stream"):
             msg = f"Vertex {vertex_id} does not support streaming"
-            logger.error(msg)
+            await logger.aerror(msg)
             yield str(StreamData(event="error", data={"error": msg}))
             return
 
@@ -460,7 +448,7 @@ async def _stream_vertex(flow_id: str, vertex_id: str, chat_service: ChatService
             yield str(stream_data)
 
         elif not vertex.frozen or not vertex.built:
-            logger.debug(f"Streaming vertex {vertex_id}")
+            await logger.adebug(f"Streaming vertex {vertex_id}")
             stream_data = StreamData(
                 event="message",
                 data={"message": f"Streaming vertex {vertex_id}"},
@@ -474,7 +462,7 @@ async def _stream_vertex(flow_id: str, vertex_id: str, chat_service: ChatService
                     )
                     yield str(stream_data)
             except Exception as exc:  # noqa: BLE001
-                logger.exception("Error building Component")
+                await logger.aexception("Error building Component")
                 exc_message = parse_exception(exc)
                 if exc_message == "The message must be an iterator or an async iterator.":
                     exc_message = "This stream has already been closed."
@@ -487,11 +475,11 @@ async def _stream_vertex(flow_id: str, vertex_id: str, chat_service: ChatService
             yield str(stream_data)
         else:
             msg = f"No result found for vertex {vertex_id}"
-            logger.error(msg)
+            await logger.aerror(msg)
             yield str(StreamData(event="error", data={"error": msg}))
             return
     finally:
-        logger.debug("Closing stream")
+        await logger.adebug("Closing stream")
         if graph:
             await chat_service.set_cache(flow_id, graph)
         yield str(StreamData(event="close", data={"message": "Stream closed"}))
@@ -625,7 +613,7 @@ async def build_public_tmp(
             flow_name=flow_name or f"{client_id}_{flow_id}",
         )
     except Exception as exc:
-        logger.exception("Error building public flow")
+        await logger.aexception("Error building public flow")
         if isinstance(exc, HTTPException):
             raise
         raise HTTPException(status_code=500, detail=str(exc)) from exc

langflow/api/v1/endpoints.py

@@ -11,7 +11,6 @@ import sqlalchemy as sa
 from fastapi import APIRouter, BackgroundTasks, Body, Depends, HTTPException, Request, UploadFile, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import StreamingResponse
-from loguru import logger
 from sqlmodel import select
 
 from langflow.api.utils import CurrentActiveUser, DbSession, parse_value
@@ -41,6 +40,7 @@ from langflow.graph.schema import RunOutputs
 from langflow.helpers.flow import get_flow_by_id_or_endpoint_name
 from langflow.helpers.user import get_user_by_flow_id_or_endpoint_name
 from langflow.interface.initialize.loading import update_params_with_load_from_db_fields
+from langflow.logging.logger import logger
 from langflow.processing.process import process_tweaks, run_graph_internal
 from langflow.schema.graph import Tweaks
 from langflow.services.auth.utils import api_key_security, get_current_active_user
@@ -184,7 +184,7 @@ async def simple_run_flow_task(
         )
 
     except Exception:  # noqa: BLE001
-        logger.exception(f"Error running flow {flow.id} task")
+        await logger.aexception(f"Error running flow {flow.id} task")
 
 
 async def consume_and_yield(queue: asyncio.Queue, client_consumed_queue: asyncio.Queue) -> AsyncGenerator:
@@ -215,7 +215,7 @@ async def consume_and_yield(queue: asyncio.Queue, client_consumed_queue: asyncio
         yield value
         get_time_yield = time.time()
         client_consumed_queue.put_nowait(event_id)
-        logger.debug(
+        await logger.adebug(
             f"consumed event {event_id} "
             f"(time in queue, {get_time - put_time:.4f}, "
             f"client {get_time_yield - get_time:.4f})"
@@ -264,7 +264,7 @@ async def run_flow_generator(
         event_manager.on_end(data={"result": result.model_dump()})
         await client_consumed_queue.get()
     except (ValueError, InvalidChatInputError, SerializationError) as e:
-        logger.error(f"Error running flow: {e}")
+        await logger.aerror(f"Error running flow: {e}")
         event_manager.on_error(data={"error": str(e)})
     finally:
         await event_manager.queue.put((None, None, time.time))
@@ -331,7 +331,7 @@ async def simplified_run_flow(
         )
 
         async def on_disconnect() -> None:
-            logger.debug("Client disconnected, closing tasks")
+            await logger.adebug("Client disconnected, closing tasks")
             main_task.cancel()
 
         return StreamingResponse(
@@ -414,7 +414,7 @@ async def webhook_run_flow(
     """
     telemetry_service = get_telemetry_service()
     start_time = time.perf_counter()
-    logger.debug("Received webhook request")
+    await logger.adebug("Received webhook request")
     error_msg = ""
     try:
         try:
@@ -442,7 +442,7 @@ async def webhook_run_flow(
                 session_id=None,
             )
 
-            logger.debug("Starting background task")
+            await logger.adebug("Starting background task")
             background_tasks.add_task(
                 simple_run_flow_task,
                 flow=flow,
@@ -553,7 +553,7 @@ async def experimental_run_flow(
         except sa.exc.StatementError as exc:
             # StatementError('(builtins.ValueError) badly formed hexadecimal UUID string')
             if "badly formed hexadecimal UUID string" in str(exc):
-                logger.error(f"Flow ID {flow_id_str} is not a valid UUID")
+                await logger.aerror(f"Flow ID {flow_id_str} is not a valid UUID")
                 # This means the Flow ID is not a valid UUID which means it can't find the flow
                 raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
             raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(exc)) from exc
@@ -600,7 +600,7 @@ async def experimental_run_flow(
 async def process(_flow_id) -> None:
     """Endpoint to process an input with a given flow_id."""
     # Raise a depreciation warning
-    logger.warning(
+    await logger.awarning(
         "The /process endpoint is deprecated and will be removed in a future version. Please use /run instead."
     )
     raise HTTPException(
@@ -643,7 +643,7 @@ async def create_upload_file(
             file_path=file_path,
         )
     except Exception as exc:
-        logger.exception("Error saving file")
+        await logger.aexception("Error saving file")
         raise HTTPException(status_code=500, detail=str(exc)) from exc
 
 

langflow/api/v1/flows.py

@@ -55,7 +55,7 @@ async def _save_flow_to_fs(flow: Flow) -> None:
             try:
                 await f.write(flow.model_dump_json())
             except OSError:
-                logger.exception("Failed to write flow %s to path %s", flow.name, flow.fs_path)
+                await logger.aexception("Failed to write flow %s to path %s", flow.name, flow.fs_path)
 
 
 async def _new_flow(

langflow/api/v1/knowledge_bases.py

@@ -6,10 +6,10 @@ from pathlib import Path
 import pandas as pd
 from fastapi import APIRouter, HTTPException
 from langchain_chroma import Chroma
-from loguru import logger
 from pydantic import BaseModel
 
 from langflow.api.utils import CurrentActiveUser
+from langflow.logging import logger
 from langflow.services.deps import get_settings_service
 
 router = APIRouter(tags=["Knowledge Bases"], prefix="/knowledge_bases")
@@ -330,7 +330,7 @@ async def list_knowledge_bases(current_user: CurrentActiveUser) -> list[Knowledg
 
             except OSError as _:
                 # Log the exception and skip directories that can't be read
-                logger.exception("Error reading knowledge base directory '%s'", kb_dir)
+                await logger.aexception("Error reading knowledge base directory '%s'", kb_dir)
                 continue
 
         # Sort by name alphabetically
@@ -422,7 +422,7 @@ async def delete_knowledge_bases_bulk(request: BulkDeleteRequest, current_user:
                 shutil.rmtree(kb_path)
                 deleted_count += 1
             except (OSError, PermissionError) as e:
-                logger.exception("Error deleting knowledge base '%s': %s", kb_name, e)
+                await logger.aexception("Error deleting knowledge base '%s': %s", kb_name, e)
                 # Continue with other deletions even if one fails
 
         if not_found_kbs and deleted_count == 0:

langflow/api/v1/mcp.py

@@ -4,7 +4,6 @@ import pydantic
 from anyio import BrokenResourceError
 from fastapi import APIRouter, HTTPException, Request, Response
 from fastapi.responses import HTMLResponse, StreamingResponse
-from loguru import logger
 from mcp import types
 from mcp.server import NotificationOptions, Server
 from mcp.server.sse import SseServerTransport
@@ -18,6 +17,7 @@ from langflow.api.v1.mcp_utils import (
     handle_mcp_errors,
     handle_read_resource,
 )
+from langflow.logging.logger import logger
 from langflow.services.deps import get_settings_service
 
 router = APIRouter(prefix="/mcp", tags=["mcp"])
@@ -83,22 +83,22 @@ async def im_alive():
 @router.get("/sse", response_class=StreamingResponse)
 async def handle_sse(request: Request, current_user: CurrentActiveMCPUser):
     msg = f"Starting SSE connection, server name: {server.name}"
-    logger.info(msg)
+    await logger.ainfo(msg)
     token = current_user_ctx.set(current_user)
     try:
         async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
             try:
                 msg = "Starting SSE connection"
-                logger.debug(msg)
+                await logger.adebug(msg)
                 msg = f"Stream types: read={type(streams[0])}, write={type(streams[1])}"
-                logger.debug(msg)
+                await logger.adebug(msg)
 
                 notification_options = NotificationOptions(
                     prompts_changed=True, resources_changed=True, tools_changed=True
                 )
                 init_options = server.create_initialization_options(notification_options)
                 msg = f"Initialization options: {init_options}"
-                logger.debug(msg)
+                await logger.adebug(msg)
 
                 try:
                     await server.run(streams[0], streams[1], init_options)
@@ -106,20 +106,20 @@ async def handle_sse(request: Request, current_user: CurrentActiveMCPUser):
                     validation_error = find_validation_error(exc)
                     if validation_error:
                         msg = "Validation error in MCP:" + str(validation_error)
-                        logger.debug(msg)
+                        await logger.adebug(msg)
                     else:
                         msg = f"Error in MCP: {exc!s}"
-                        logger.debug(msg)
+                        await logger.adebug(msg)
                         return
             except BrokenResourceError:
                 # Handle gracefully when client disconnects
-                logger.info("Client disconnected from SSE connection")
+                await logger.ainfo("Client disconnected from SSE connection")
             except asyncio.CancelledError:
-                logger.info("SSE connection was cancelled")
+                await logger.ainfo("SSE connection was cancelled")
                 raise
             except Exception as e:
                 msg = f"Error in MCP: {e!s}"
-                logger.exception(msg)
+                await logger.aexception(msg)
                 raise
     finally:
         current_user_ctx.reset(token)
@@ -130,8 +130,8 @@ async def handle_messages(request: Request):
     try:
         await sse.handle_post_message(request.scope, request.receive, request._send)
     except (BrokenResourceError, BrokenPipeError) as e:
-        logger.info("MCP Server disconnected")
+        await logger.ainfo("MCP Server disconnected")
         raise HTTPException(status_code=404, detail=f"MCP Server disconnected, error: {e}") from e
     except Exception as e:
-        logger.error(f"Internal server error: {e}")
+        await logger.aerror(f"Internal server error: {e}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {e}") from e