chore: 部分去除print改用logger

Fix/20250309 logger optimize

bot.py

@@ -1,5 +1,7 @@
 import os
 import shutil
+import sys
+
 import nonebot
 import time
 from dotenv import load_dotenv
@@ -10,6 +12,7 @@ import platform
 # 获取没有加载env时的环境变量
 env_mask = {key: os.getenv(key) for key in os.environ}
 
+
 def easter_egg():
     # 彩蛋
     from colorama import init, Fore
@@ -22,6 +25,7 @@ def easter_egg():
         rainbow_text += rainbow_colors[i % len(rainbow_colors)] + char
     print(rainbow_text)
 
+
 def init_config():
     # 初次启动检测
     if not os.path.exists("config/bot_config.toml"):
@@ -35,6 +39,7 @@ def init_config():
         shutil.copy("template/bot_config_template.toml", "config/bot_config.toml")
         logger.info("复制完成，请修改config/bot_config.toml和.env.prod中的配置后重新启动")
 
+
 def init_env():
     # 初始化.env 默认ENVIRONMENT=prod
     if not os.path.exists(".env"):
@@ -46,11 +51,17 @@ def init_env():
             logger.error("检测到.env.prod文件不存在")
             shutil.copy("template.env", "./.env.prod")
 
+    # 检测.env.dev文件是否存在，不存在的话直接复制生产环境配置
+    if not os.path.exists(".env.dev"):
+        logger.error("检测到.env.dev文件不存在")
+        shutil.copy(".env.prod", "./.env.dev")
+
     # 首先加载基础环境变量.env
     if os.path.exists(".env"):
         load_dotenv(".env")
         logger.success("成功加载基础环境变量配置")
 
+
 def load_env():
     # 使用闭包实现对加载器的横向扩展，避免大量重复判断
     def prod():
@@ -81,6 +92,17 @@ def load_env():
         RuntimeError(f"ENVIRONMENT 配置错误，请检查 .env 文件中的 ENVIRONMENT 变量及对应 .env.{env} 是否存在")
 
 
+def load_logger():
+    logger.remove()  # 移除默认配置
+    logger.add(
+        sys.stderr,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> <fg #777777>|</> <level>{level: <7}</level> <fg "
+               "#777777>|</> <cyan>{name:.<8}</cyan>:<cyan>{function:.<8}</cyan>:<cyan>{line: >4}</cyan> <fg "
+               "#777777>-</> <level>{message}</level>",
+        colorize=True,
+        level=os.getenv("LOG_LEVEL", "INFO")  # 根据环境设置日志级别，默认为INFO
+    )
+
 
 def scan_provider(env_config: dict):
     provider = {}
@@ -115,6 +137,7 @@ def scan_provider(env_config: dict):
             )
             raise ValueError(f"请检查 '{provider_name}' 提供商配置是否丢失 BASE_URL 或 KEY 环境变量")
 
+
 if __name__ == "__main__":
     # 利用 TZ 环境变量设定程序工作的时区
     # 仅保证行为一致，不依赖 localtime()，实际对生产环境几乎没有作用
@@ -122,6 +145,7 @@ if __name__ == "__main__":
         time.tzset()
 
     easter_egg()
+    load_logger()
     init_config()
     init_env()
     load_env()

src/plugins/chat/__init__.py

@@ -1,6 +1,4 @@
 import asyncio
-import os
-import random
 import time
 
 from loguru import logger
@@ -39,7 +37,6 @@ Database.initialize(
 )
 print("\033[1;32m[初始化数据库完成]\033[0m")
 
-
 # 导入其他模块
 from ..memory_system.memory import hippocampus, memory_graph
 from .bot import ChatBot
@@ -59,24 +56,24 @@ group_msg = on_message(priority=5)
 scheduler = require("nonebot_plugin_apscheduler").scheduler
 
 
-
 @driver.on_startup
 async def start_background_tasks():
     """启动后台任务"""
     # 启动LLM统计
     llm_stats.start()
-    print("\033[1;32m[初始化]\033[0m LLM统计功能已启动")
+    logger.success("[初始化]LLM统计功能已启动")
 
     # 初始化并启动情绪管理器
     mood_manager = MoodManager.get_instance()
     mood_manager.start_mood_update(update_interval=global_config.mood_update_interval)
-    print("\033[1;32m[初始化]\033[0m 情绪管理器已启动")
+    logger.success("[初始化]情绪管理器已启动")
 
     # 只启动表情包管理任务
     asyncio.create_task(emoji_manager.start_periodic_check(interval_MINS=global_config.EMOJI_CHECK_INTERVAL))
     await bot_schedule.initialize()
     bot_schedule.print_schedule()
 
+
 @driver.on_startup
 async def init_relationships():
     """在 NoneBot2 启动时初始化关系管理器"""
@@ -84,6 +81,7 @@ async def init_relationships():
     await relationship_manager.load_all_relationships()
     asyncio.create_task(relationship_manager._start_relationship_manager())
 
+
 @driver.on_bot_connect
 async def _(bot: Bot):
     """Bot连接成功时的处理"""
@@ -102,19 +100,24 @@ async def _(bot: Bot):
     asyncio.create_task(emoji_manager._periodic_scan(interval_MINS=global_config.EMOJI_REGISTER_INTERVAL))
     print("\033[1;38;5;208m-----------开始偷表情包！-----------\033[0m")
 
+
 @group_msg.handle()
 async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
     await chat_bot.handle_message(event, bot)
 
+
 # 添加build_memory定时任务
 @scheduler.scheduled_job("interval", seconds=global_config.build_memory_interval, id="build_memory")
 async def build_memory_task():
     """每build_memory_interval秒执行一次记忆构建"""
-    print("\033[1;32m[记忆构建]\033[0m -------------------------------------------开始构建记忆-------------------------------------------")
+    print(
+        "\033[1;32m[记忆构建]\033[0m -------------------------------------------开始构建记忆-------------------------------------------")
     start_time = time.time()
     await hippocampus.operation_build_memory(chat_size=20)
     end_time = time.time()
-    print(f"\033[1;32m[记忆构建]\033[0m -------------------------------------------记忆构建完成：耗时: {end_time - start_time:.2f} 秒-------------------------------------------")
+    print(
+        f"\033[1;32m[记忆构建]\033[0m -------------------------------------------记忆构建完成：耗时: {end_time - start_time:.2f} 秒-------------------------------------------")
+
 
 @scheduler.scheduled_job("interval", seconds=global_config.forget_memory_interval, id="forget_memory")
 async def forget_memory_task():
@@ -123,6 +126,7 @@ async def forget_memory_task():
     # await hippocampus.operation_forget_topic(percentage=0.1)
     # print("\033[1;32m[记忆遗忘]\033[0m 记忆遗忘完成")
 
+
 @scheduler.scheduled_job("interval", seconds=global_config.build_memory_interval + 10, id="merge_memory")
 async def merge_memory_task():
     """每30秒执行一次记忆构建"""
@@ -130,9 +134,9 @@ async def merge_memory_task():
     # await hippocampus.operation_merge_memory(percentage=0.1)
     # print("\033[1;32m[记忆整合]\033[0m 记忆整合完成")
 
+
 @scheduler.scheduled_job("interval", seconds=30, id="print_mood")
 async def print_mood_task():
     """每30秒打印一次情绪状态"""
     mood_manager = MoodManager.get_instance()
     mood_manager.print_mood_status()
-  

src/plugins/chat/config.py

@@ -8,6 +8,7 @@ from packaging import version
 from packaging.version import Version, InvalidVersion
 from packaging.specifiers import SpecifierSet, InvalidSpecifier
 
+
 @dataclass
 class BotConfig:
     """机器人配置类"""
@@ -82,6 +83,7 @@ class BotConfig:
         "是一个女大学生，你有黑色头发，你会刷小红书",
         "是一个女大学生，你会刷b站，对ACG文化感兴趣"
     ]
+
     PROMPT_SCHEDULE_GEN="一个曾经学习地质,现在学习心理学和脑科学的女大学生，喜欢刷qq，贴吧，知乎和小红书"
     
     PERSONALITY_1: float = 0.6 # 第一种人格概率
@@ -193,7 +195,8 @@ class BotConfig:
             response_config = parent["response"]
             config.MODEL_R1_PROBABILITY = response_config.get("model_r1_probability", config.MODEL_R1_PROBABILITY)
             config.MODEL_V3_PROBABILITY = response_config.get("model_v3_probability", config.MODEL_V3_PROBABILITY)
-            config.MODEL_R1_DISTILL_PROBABILITY = response_config.get("model_r1_distill_probability", config.MODEL_R1_DISTILL_PROBABILITY)
+            config.MODEL_R1_DISTILL_PROBABILITY = response_config.get("model_r1_distill_probability",
+                                                                      config.MODEL_R1_DISTILL_PROBABILITY)
             config.max_response_length = response_config.get("max_response_length", config.max_response_length)
 
         def model(parent: dict):
@@ -246,7 +249,6 @@ class BotConfig:
                                     logger.error(f"{item} 中的必要字段 {e} 不存在，请检查")
                                     raise KeyError(f"{item} 中的必要字段 {e} 不存在，请检查")
 
-
                         provider = cfg_item.get("provider")
                         if provider == None:
                             logger.error(f"provider 字段在模型配置 {item} 中不存在，请检查")
@@ -255,7 +257,6 @@ class BotConfig:
                         cfg_target["base_url"] = f"{provider}_BASE_URL"
                         cfg_target["key"] = f"{provider}_KEY"
 
-                    
                     # 如果 列表中的项目在 model_config 中，利用反射来设置对应项目
                     setattr(config, item, cfg_target)
                 else:
@@ -271,8 +272,10 @@ class BotConfig:
 
             if config.INNER_VERSION in SpecifierSet(">=0.0.2"):
                 config.thinking_timeout = msg_config.get("thinking_timeout", config.thinking_timeout)
-                config.response_willing_amplifier = msg_config.get("response_willing_amplifier", config.response_willing_amplifier)
+                config.response_willing_amplifier = msg_config.get("response_willing_amplifier",
-                config.response_interested_rate_amplifier = msg_config.get("response_interested_rate_amplifier", config.response_interested_rate_amplifier)
+                                                                   config.response_willing_amplifier)
+                config.response_interested_rate_amplifier = msg_config.get("response_interested_rate_amplifier",
+                                                                           config.response_interested_rate_amplifier)
                 config.down_frequency_rate = msg_config.get("down_frequency_rate", config.down_frequency_rate)
 
         def memory(parent: dict):
@@ -300,8 +303,10 @@ class BotConfig:
             config.chinese_typo_enable = chinese_typo_config.get("enable", config.chinese_typo_enable)
             config.chinese_typo_error_rate = chinese_typo_config.get("error_rate", config.chinese_typo_error_rate)
             config.chinese_typo_min_freq = chinese_typo_config.get("min_freq", config.chinese_typo_min_freq)
-            config.chinese_typo_tone_error_rate = chinese_typo_config.get("tone_error_rate", config.chinese_typo_tone_error_rate)
+            config.chinese_typo_tone_error_rate = chinese_typo_config.get("tone_error_rate",
-            config.chinese_typo_word_replace_rate = chinese_typo_config.get("word_replace_rate", config.chinese_typo_word_replace_rate)
+                                                                          config.chinese_typo_tone_error_rate)
+            config.chinese_typo_word_replace_rate = chinese_typo_config.get("word_replace_rate",
+                                                                            config.chinese_typo_word_replace_rate)
 
         def groups(parent: dict):
             groups_config = parent["groups"]
@@ -429,15 +434,16 @@ class BotConfig:
 
         return config
 
+
 # 获取配置文件路径
 bot_config_floder_path = BotConfig.get_config_dir()
-print(f"正在品鉴配置文件目录: {bot_config_floder_path}")
+logger.debug(f"正在品鉴配置文件目录: {bot_config_floder_path}")
 
 bot_config_path = os.path.join(bot_config_floder_path, "bot_config.toml")
 
 if os.path.exists(bot_config_path):
     # 如果开发环境配置文件不存在，则使用默认配置文件
-    print(f"异常的新鲜，异常的美味: {bot_config_path}")
+    logger.debug(f"异常的新鲜，异常的美味: {bot_config_path}")
     logger.info("使用bot配置文件")
 else:
     # 配置文件不存在
@@ -446,8 +452,6 @@ else:
 
 global_config = BotConfig.load_config(config_path=bot_config_path)
 
-
 if not global_config.enable_advance_output:
     logger.remove()
     pass
-

src/plugins/schedule/schedule_generator.py

@@ -13,7 +13,6 @@ from ..models.utils_model import LLM_request
 driver = get_driver()
 config = driver.config
 
-
 Database.initialize(
     host=config.MONGODB_HOST,
     port=int(config.MONGODB_PORT),
@@ -23,6 +22,7 @@ Database.initialize(
     auth_source=config.MONGODB_AUTH_SOURCE
 )
 
+
 class ScheduleGenerator:
     def __init__(self):
         # 根据global_config.llm_normal这一字典配置指定模型
@@ -42,25 +42,27 @@ class ScheduleGenerator:
         yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
 
         self.today_schedule_text, self.today_schedule = await self.generate_daily_schedule(target_date=today)
-        self.tomorrow_schedule_text, self.tomorrow_schedule = await self.generate_daily_schedule(target_date=tomorrow,read_only=True)
+        self.tomorrow_schedule_text, self.tomorrow_schedule = await self.generate_daily_schedule(target_date=tomorrow,
-        self.yesterday_schedule_text, self.yesterday_schedule = await self.generate_daily_schedule(target_date=yesterday,read_only=True)
+                                                                                                 read_only=True)
+        self.yesterday_schedule_text, self.yesterday_schedule = await self.generate_daily_schedule(
+            target_date=yesterday, read_only=True)
 
-    async def generate_daily_schedule(self, target_date: datetime.datetime = None,read_only:bool = False) -> Dict[str, str]:
+    async def generate_daily_schedule(self, target_date: datetime.datetime = None, read_only: bool = False) -> Dict[
+        str, str]:
 
         date_str = target_date.strftime("%Y-%m-%d")
         weekday = target_date.strftime("%A")
 
-
         schedule_text = str
 
         existing_schedule = self.db.db.schedule.find_one({"date": date_str})
         if existing_schedule:
-            print(f"{date_str}的日程已存在:")
+            logger.info(f"{date_str}的日程已存在:")
             schedule_text = existing_schedule["schedule"]
             # print(self.schedule_text)
 
         elif read_only == False:
-            print(f"{date_str}的日程不存在，准备生成新的日程。")
+            logger.info(f"{date_str}的日程不存在，准备生成新的日程。")
             prompt = f"""我是{global_config.BOT_NICKNAME}，{global_config.PROMPT_SCHEDULE_GEN}，请为我生成{date_str}（{weekday}）的日程安排，包括：""" + \
                      """
             1. 早上的学习和工作安排
@@ -76,7 +78,7 @@ class ScheduleGenerator:
                 schedule_text = "生成日程时出错了"
             # print(self.schedule_text)
         else:
-            print(f"{date_str}的日程不存在。")
+            logger.info(f"{date_str}的日程不存在。")
             schedule_text = "忘了"
 
             return schedule_text, None
@@ -90,8 +92,7 @@ class ScheduleGenerator:
             schedule_dict = json.loads(schedule_text)
             return schedule_dict
         except json.JSONDecodeError as e:
-            print(schedule_text)
+            logger.exception("解析日程失败: {}".format(schedule_text))
-            print(f"解析日程失败: {str(e)}")
             return False
 
     def _parse_time(self, time_str: str) -> str:
@@ -150,13 +151,14 @@ class ScheduleGenerator:
     def print_schedule(self):
         """打印完整的日程安排"""
         if not self._parse_schedule(self.today_schedule_text):
-            print("今日日程有误，将在下次运行时重新生成")
+            logger.warning("今日日程有误，将在下次运行时重新生成")
             self.db.db.schedule.delete_one({"date": datetime.datetime.now().strftime("%Y-%m-%d")})
         else:
-            print("\n=== 今日日程安排 ===")
+            logger.info("\n=== 今日日程安排 ===")
             for time_str, activity in self.today_schedule.items():
-                print(f"时间[{time_str}]: 活动[{activity}]")
+                logger.info(f"时间[{time_str}]: 活动[{activity}]")
-            print("==================\n")
+            logger.info("==================\n")
+
 
 # def main():
 #     # 使用示例