Merge pull request #602 from pipecat-ai/mb/adjust-logger-levels

Adjust log levels for log messages

examples/storytelling-chatbot/src/bot.py

@@ -1,11 +1,16 @@
 import argparse
 import asyncio
-import aiohttp
 import os
 import sys
 
+import aiohttp
+from dotenv import load_dotenv
+from loguru import logger
+from processors import StoryImageProcessor, StoryProcessor
+from prompts import CUE_USER_TURN, LLM_BASE_PROMPT, LLM_INTRO_PROMPT
+from utils.helpers import load_images, load_sounds
 
-from pipecat.frames.frames import LLMMessagesFrame, StopTaskFrame, EndFrame
+from pipecat.frames.frames import EndFrame, LLMMessagesFrame, StopTaskFrame
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
 from pipecat.pipeline.task import PipelineTask
@@ -22,14 +27,6 @@ from pipecat.transports.services.daily import (
     DailyTransportMessageFrame,
 )
 
-from processors import StoryProcessor, StoryImageProcessor
-from prompts import LLM_BASE_PROMPT, LLM_INTRO_PROMPT, CUE_USER_TURN
-from utils.helpers import load_sounds, load_images
-
-from loguru import logger
-
-from dotenv import load_dotenv
-
 load_dotenv(override=True)
 
 logger.remove(0)

src/pipecat/processors/aggregators/openai_llm_context.py

@@ -8,30 +8,26 @@ import base64
 import copy
 import io
 import json
-
 from dataclasses import dataclass
-
 from typing import Any, Awaitable, Callable, List
 
+from loguru import logger
 from PIL import Image
 
 from pipecat.frames.frames import (
     Frame,
-    VisionImageRawFrame,
     FunctionCallInProgressFrame,
     FunctionCallResultFrame,
+    VisionImageRawFrame,
 )
 from pipecat.processors.frame_processor import FrameProcessor
 
-from loguru import logger
-
 try:
     from openai._types import NOT_GIVEN, NotGiven
-
     from openai.types.chat import (
-        ChatCompletionToolParam,
-        ChatCompletionToolChoiceOptionParam,
         ChatCompletionMessageParam,
+        ChatCompletionToolChoiceOptionParam,
+        ChatCompletionToolParam,
     )
 except ModuleNotFoundError as e:
     logger.error(f"Exception: {e}")
@@ -185,7 +181,7 @@ class OpenAILLMContext:
         llm: FrameProcessor,
         run_llm: bool = True,
     ) -> None:
-        logger.debug(f"Calling function {function_name} with arguments {arguments}")
+        logger.info(f"Calling function {function_name} with arguments {arguments}")
         # Push a SystemFrame downstream. This frame will let our assistant context aggregator
         # know that we are in the middle of a function call. Some contexts/aggregators may
         # not need this. But some definitely do (Anthropic, for example).

src/pipecat/services/ai_services.py

@@ -75,7 +75,7 @@ class AIService(FrameProcessor):
             print("Update request for:", key, value)
 
             if key in self._settings:
-                logger.debug(f"Updating LLM setting {key} to: [{value}]")
+                logger.info(f"Updating LLM setting {key} to: [{value}]")
                 self._settings[key] = value
             elif key in SessionProperties.model_fields:
                 print("Attempting to update", key, value)
@@ -99,12 +99,12 @@ class AIService(FrameProcessor):
                     validated_properties = SessionProperties.model_validate(
                         current_properties.model_dump()
                     )
-                    logger.debug(f"Updating LLM setting {key} to: [{value}]")
+                    logger.info(f"Updating LLM setting {key} to: [{value}]")
                     self._session_properties = validated_properties.model_dump()
                 except Exception as e:
                     logger.warning(f"Unexpected error updating session property {key}: {e}")
             elif key == "model":
-                logger.debug(f"Updating LLM setting {key} to: [{value}]")
+                logger.info(f"Updating LLM setting {key} to: [{value}]")
                 self.set_model_name(value)
             else:
                 logger.warning(f"Unknown setting for {self.name} service: {key}")
@@ -271,7 +271,7 @@ class TTSService(AIService):
     async def _update_settings(self, settings: Dict[str, Any]):
         for key, value in settings.items():
             if key in self._settings:
-                logger.debug(f"Updating TTS setting {key} to: [{value}]")
+                logger.info(f"Updating TTS setting {key} to: [{value}]")
                 self._settings[key] = value
                 if key == "language":
                     self._settings[key] = self.language_to_service_language(value)
@@ -470,10 +470,10 @@ class STTService(AIService):
         pass
 
     async def _update_settings(self, settings: Dict[str, Any]):
-        logger.debug(f"Updating STT settings: {self._settings}")
+        logger.info(f"Updating STT settings: {self._settings}")
         for key, value in settings.items():
             if key in self._settings:
-                logger.debug(f"Updating STT setting {key} to: [{value}]")
+                logger.info(f"Updating STT setting {key} to: [{value}]")
                 self._settings[key] = value
                 if key == "language":
                     await self.set_language(value)

src/pipecat/services/cartesia.py

@@ -18,7 +18,6 @@ from pipecat.frames.frames import (
     EndFrame,
     ErrorFrame,
     Frame,
-    LLMFullResponseEndFrame,
     StartFrame,
     StartInterruptionFrame,
     TTSAudioRawFrame,
@@ -132,7 +131,7 @@ class CartesiaTTSService(WordTTSService):
     async def set_model(self, model: str):
         self._model_id = model
         await super().set_model(model)
-        logger.debug(f"Switching TTS model to: [{model}]")
+        logger.info(f"Switching TTS model to: [{model}]")
 
     def language_to_service_language(self, language: Language) -> str | None:
         return language_to_cartesia_language(language)

src/pipecat/services/deepgram.py

@@ -162,13 +162,13 @@ class DeepgramSTTService(STTService):
 
     async def set_model(self, model: str):
         await super().set_model(model)
-        logger.debug(f"Switching STT model to: [{model}]")
+        logger.info(f"Switching STT model to: [{model}]")
         self._settings["model"] = model
         await self._disconnect()
         await self._connect()
 
     async def set_language(self, language: Language):
-        logger.debug(f"Switching STT language to: [{language}]")
+        logger.info(f"Switching STT language to: [{language}]")
         self._settings["language"] = language
         await self._disconnect()
         await self._connect()
@@ -191,14 +191,14 @@ class DeepgramSTTService(STTService):
 
     async def _connect(self):
         if await self._connection.start(self._settings):
-            logger.debug(f"{self}: Connected to Deepgram")
+            logger.info(f"{self}: Connected to Deepgram")
         else:
             logger.error(f"{self}: Unable to connect to Deepgram")
 
     async def _disconnect(self):
         if self._connection.is_connected:
             await self._connection.finish()
-            logger.debug(f"{self}: Disconnected from Deepgram")
+            logger.info(f"{self}: Disconnected from Deepgram")
 
     async def _on_speech_started(self, *args, **kwargs):
         await self.start_ttfb_metrics()

src/pipecat/services/elevenlabs.py

@@ -247,7 +247,7 @@ class ElevenLabsTTSService(WordTTSService):
 
     async def set_model(self, model: str):
         await super().set_model(model)
-        logger.debug(f"Switching TTS model to: [{model}]")
+        logger.info(f"Switching TTS model to: [{model}]")
         await self._disconnect()
         await self._connect()
 
@@ -257,7 +257,7 @@ class ElevenLabsTTSService(WordTTSService):
         if not prev_voice == self._voice_id:
             await self._disconnect()
             await self._connect()
-            logger.debug(f"Switching TTS voice to: [{self._voice_id}]")
+            logger.info(f"Switching TTS voice to: [{self._voice_id}]")
 
     async def start(self, frame: StartFrame):
         await super().start(frame)
@@ -298,7 +298,7 @@ class ElevenLabsTTSService(WordTTSService):
             if model == "eleven_turbo_v2_5":
                 url += f"&language_code={language}"
             else:
-                logger.debug(
+                logger.warning(
                     f"Language code [{language}] not applied. Language codes can only be used with the 'eleven_turbo_v2_5' model."
                 )
 

src/pipecat/services/openai.py

@@ -400,7 +400,7 @@ class OpenAITTSService(TTSService):
         return True
 
     async def set_model(self, model: str):
-        logger.debug(f"Switching TTS model to: [{model}]")
+        logger.info(f"Switching TTS model to: [{model}]")
         self.set_model_name(model)
 
     async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:

src/pipecat/vad/vad_analyzer.py

@@ -7,12 +7,11 @@
 from abc import abstractmethod
 from enum import Enum
 
+from loguru import logger
 from pydantic.main import BaseModel
 
 from pipecat.utils.audio import calculate_audio_volume, exp_smoothing
 
-from loguru import logger
-
 
 class VADState(Enum):
     QUIET = 1
@@ -58,7 +57,7 @@ class VADAnalyzer:
         pass
 
     def set_params(self, params: VADParams):
-        logger.debug(f"Setting VAD params to: {params}")
+        logger.info(f"Setting VAD params to: {params}")
         self._params = params
         self._vad_frames = self.num_frames_required()
         self._vad_frames_num_bytes = self._vad_frames * self._num_channels * 2