diff --git a/src/chat/message_manager/message_manager.py b/src/chat/message_manager/message_manager.py index d20c67321..88b2c8ae7 100644 --- a/src/chat/message_manager/message_manager.py +++ b/src/chat/message_manager/message_manager.py @@ -13,7 +13,8 @@ from src.common.data_models.database_data_model import DatabaseMessages from src.common.data_models.message_manager_data_model import StreamContext, MessageManagerStats, StreamStats from src.chat.chatter_manager import ChatterManager from src.chat.planner_actions.action_manager import ChatterActionManager -from src.plugin_system.base.component_types import ChatMode +from .sleep_manager.sleep_manager import SleepManager +from .sleep_manager.wakeup_manager import WakeUpManager if TYPE_CHECKING: from src.common.data_models.message_manager_data_model import StreamContext @@ -37,6 +38,10 @@ class MessageManager: self.action_manager = ChatterActionManager() self.chatter_manager = ChatterManager(self.action_manager) + # 初始化睡眠和唤醒管理器 + self.sleep_manager = SleepManager() + self.wakeup_manager = WakeUpManager(self.sleep_manager) + async def start(self): """启动消息管理器""" if self.is_running: @@ -45,6 +50,7 @@ class MessageManager: self.is_running = True self.manager_task = asyncio.create_task(self._manager_loop()) + await self.wakeup_manager.start() logger.info("消息管理器已启动") async def stop(self): @@ -62,6 +68,8 @@ class MessageManager: # 停止管理器任务 if self.manager_task and not self.manager_task.done(): self.manager_task.cancel() + + await self.wakeup_manager.stop() logger.info("消息管理器已停止") @@ -82,6 +90,9 @@ class MessageManager: """管理器主循环""" while self.is_running: try: + # 更新睡眠状态 + await self.sleep_manager.update_sleep_state(self.wakeup_manager) + await self._check_all_streams() await asyncio.sleep(self.check_interval) except asyncio.CancelledError: @@ -126,6 +137,28 @@ class MessageManager: unread_messages = context.get_unread_messages() if not unread_messages: return + + # --- 睡眠状态检查 --- + from .sleep_manager.sleep_state import SleepState + if self.sleep_manager.is_sleeping(): + logger.info(f"Bot正在睡觉，检查聊天流 {stream_id} 是否有唤醒触发器。") + + was_woken_up = False + is_private = context.is_private_chat() + + for message in unread_messages: + is_mentioned = message.is_mentioned or False + if is_private or is_mentioned: + if self.wakeup_manager.add_wakeup_value(is_private, is_mentioned): + was_woken_up = True + break # 一旦被吵醒，就跳出循环并处理消息 + + if not was_woken_up: + logger.debug(f"聊天流 {stream_id} 中没有唤醒触发器，保持消息未读状态。") + return # 退出，不处理消息 + + logger.info(f"Bot被聊天流 {stream_id} 中的消息吵醒，继续处理。") + # --- 睡眠状态检查结束 --- logger.debug(f"开始处理聊天流 {stream_id} 的 {len(unread_messages)} 条未读消息") @@ -189,7 +222,7 @@ class MessageManager: unread_count=len(context.get_unread_messages()), history_count=len(context.history_messages), last_check_time=context.last_check_time, - has_active_task=context.processing_task and not context.processing_task.done(), + has_active_task=bool(context.processing_task and not context.processing_task.done()), ) def get_manager_stats(self) -> Dict[str, Any]: diff --git a/src/chat/message_manager/sleep_manager/notification_sender.py b/src/chat/message_manager/sleep_manager/notification_sender.py new file mode 100644 index 000000000..a22aa9b4e --- /dev/null +++ b/src/chat/message_manager/sleep_manager/notification_sender.py @@ -0,0 +1,32 @@ +from src.common.logger import get_logger +from ..hfc_context import HfcContext + +logger = get_logger("notification_sender") + + +class NotificationSender: + @staticmethod + async def send_goodnight_notification(context: HfcContext): + """发送晚安通知""" + #try: + #from ..proactive.events import ProactiveTriggerEvent + #from ..proactive.proactive_thinker import ProactiveThinker + + #event = ProactiveTriggerEvent(source="sleep_manager", reason="goodnight") + #proactive_thinker = ProactiveThinker(context, context.chat_instance.cycle_processor) + #await proactive_thinker.think(event) + #except Exception as e: + #logger.error(f"发送晚安通知失败: {e}") + + @staticmethod + async def send_insomnia_notification(context: HfcContext, reason: str): + """发送失眠通知""" + #try: + #from ..proactive.events import ProactiveTriggerEvent + #from ..proactive.proactive_thinker import ProactiveThinker + + #event = ProactiveTriggerEvent(source="sleep_manager", reason=reason) + #proactive_thinker = ProactiveThinker(context, context.chat_instance.cycle_processor) + #await proactive_thinker.think(event) + #except Exception as e: + #logger.error(f"发送失眠通知失败: {e}") \ No newline at end of file diff --git a/src/chat/message_manager/sleep_manager/sleep_manager.py b/src/chat/message_manager/sleep_manager/sleep_manager.py new file mode 100644 index 000000000..ad4aa1ced --- /dev/null +++ b/src/chat/message_manager/sleep_manager/sleep_manager.py @@ -0,0 +1,304 @@ +import asyncio +import random +from datetime import datetime, timedelta, date +from typing import Optional, TYPE_CHECKING + +from src.common.logger import get_logger +from src.config.config import global_config +from .notification_sender import NotificationSender +from .sleep_state import SleepState, SleepStateSerializer +from .time_checker import TimeChecker + +if TYPE_CHECKING: + pass + +logger = get_logger("sleep_manager") + + +class SleepManager: + """ + 睡眠管理器，核心组件之一，负责管理角色的睡眠周期和状态转换。 + 它实现了一个状态机，根据预设的时间表、睡眠压力和随机因素， + 在不同的睡眠状态（如清醒、准备入睡、睡眠、失眠）之间进行切换。 + """ + def __init__(self): + """ + 初始化睡眠管理器。 + """ + self.time_checker = TimeChecker() # 时间检查器，用于判断当前是否处于理论睡眠时间 + self.last_sleep_log_time = 0 # 上次记录睡眠日志的时间戳 + self.sleep_log_interval = 35 # 睡眠日志记录间隔（秒） + + # --- 统一睡眠状态管理 --- + self._current_state: SleepState = SleepState.AWAKE # 当前睡眠状态 + self._sleep_buffer_end_time: Optional[datetime] = None # 睡眠缓冲结束时间，用于状态转换 + self._total_delayed_minutes_today: float = 0.0 # 今天总共延迟入睡的分钟数 + self._last_sleep_check_date: Optional[date] = None # 上次检查睡眠状态的日期 + self._last_fully_slept_log_time: float = 0 # 上次完全进入睡眠状态的时间戳 + self._re_sleep_attempt_time: Optional[datetime] = None # 被吵醒后，尝试重新入睡的时间点 + + # 从本地存储加载上一次的睡眠状态 + self._load_sleep_state() + + def get_current_sleep_state(self) -> SleepState: + """获取当前的睡眠状态。""" + return self._current_state + + def is_sleeping(self) -> bool: + """判断当前是否处于正在睡觉的状态。""" + return self._current_state == SleepState.SLEEPING + + async def update_sleep_state(self, wakeup_manager: Optional["WakeUpManager"] = None): + """ + 更新睡眠状态的核心方法，实现状态机的主要逻辑。 + 该方法会被周期性调用，以检查并更新当前的睡眠状态。 + + Args: + wakeup_manager (Optional["WakeUpManager"]): 唤醒管理器，用于获取睡眠压力等上下文信息。 + """ + # 如果全局禁用了睡眠系统，则强制设置为清醒状态并返回 + if not global_config.sleep_system.enable: + if self._current_state != SleepState.AWAKE: + logger.debug("睡眠系统禁用，强制设为 AWAKE") + self._current_state = SleepState.AWAKE + return + + now = datetime.now() + today = now.date() + + # 跨天处理：如果日期变化，重置每日相关的睡眠状态 + if self._last_sleep_check_date != today: + logger.info(f"新的一天 ({today})，重置睡眠状态。") + self._total_delayed_minutes_today = 0 + self._current_state = SleepState.AWAKE + self._sleep_buffer_end_time = None + self._last_sleep_check_date = today + self._save_sleep_state() + + # 检查当前是否处于理论上的睡眠时间段 + is_in_theoretical_sleep, activity = self.time_checker.is_in_theoretical_sleep_time(now.time()) + + # --- 状态机核心处理逻辑 --- + if self._current_state == SleepState.AWAKE: + if is_in_theoretical_sleep: + self._handle_awake_to_sleep(now, activity, wakeup_manager) + + elif self._current_state == SleepState.PREPARING_SLEEP: + self._handle_preparing_sleep(now, is_in_theoretical_sleep, wakeup_manager) + + elif self._current_state == SleepState.SLEEPING: + self._handle_sleeping(now, is_in_theoretical_sleep, activity, wakeup_manager) + + elif self._current_state == SleepState.INSOMNIA: + self._handle_insomnia(now, is_in_theoretical_sleep) + + elif self._current_state == SleepState.WOKEN_UP: + self._handle_woken_up(now, is_in_theoretical_sleep, wakeup_manager) + + def _handle_awake_to_sleep(self, now: datetime, activity: Optional[str], wakeup_manager: Optional["WakeUpManager"]): + """处理从“清醒”到“准备入睡”的状态转换。""" + if activity: + logger.info(f"进入理论休眠时间 '{activity}'，开始进行睡眠决策...") + else: + logger.info("进入理论休眠时间，开始进行睡眠决策...") + + if global_config.sleep_system.enable_flexible_sleep: + # --- 新的弹性睡眠逻辑 --- + if wakeup_manager: + sleep_pressure = wakeup_manager.context.sleep_pressure + pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold + max_delay_minutes = global_config.sleep_system.max_sleep_delay_minutes + + buffer_seconds = 0 + # 如果睡眠压力低于阈值，则计算延迟时间 + if sleep_pressure <= pressure_threshold: + # 压力差，归一化到 (0, 1] + pressure_diff = (pressure_threshold - sleep_pressure) / pressure_threshold + # 延迟分钟数，压力越低，延迟越长 + delay_minutes = int(pressure_diff * max_delay_minutes) + + # 确保总延迟不超过当日最大值 + remaining_delay = max_delay_minutes - self._total_delayed_minutes_today + delay_minutes = min(delay_minutes, remaining_delay) + + if delay_minutes > 0: + # 增加一些随机性 + buffer_seconds = random.randint(int(delay_minutes * 0.8 * 60), int(delay_minutes * 1.2 * 60)) + self._total_delayed_minutes_today += buffer_seconds / 60.0 + logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 较低，延迟 {buffer_seconds / 60:.1f} 分钟入睡。") + else: + # 延迟额度已用完，设置一个较短的准备时间 + buffer_seconds = random.randint(1 * 60, 2 * 60) + logger.info("今日延迟入睡额度已用完，进入短暂准备后入睡。") + else: + # 睡眠压力较高，设置一个较短的准备时间 + buffer_seconds = random.randint(1 * 60, 2 * 60) + logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 较高，将在短暂准备后入睡。") + + # 发送睡前通知 + if global_config.sleep_system.enable_pre_sleep_notification: + asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context)) + + self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self._current_state = SleepState.PREPARING_SLEEP + logger.info(f"进入准备入睡状态，将在 {buffer_seconds / 60:.1f} 分钟内入睡。") + self._save_sleep_state() + else: + # 无法获取 wakeup_manager，退回旧逻辑 + buffer_seconds = random.randint(1 * 60, 3 * 60) + self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self._current_state = SleepState.PREPARING_SLEEP + logger.warning("无法获取 WakeUpManager，弹性睡眠采用默认1-3分钟延迟。") + self._save_sleep_state() + else: + # 非弹性睡眠模式 + if wakeup_manager and global_config.sleep_system.enable_pre_sleep_notification: + asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context)) + self._current_state = SleepState.SLEEPING + + + def _handle_preparing_sleep(self, now: datetime, is_in_theoretical_sleep: bool, wakeup_manager: Optional["WakeUpManager"]): + """处理“准备入睡”状态下的逻辑。""" + # 如果在准备期间离开了理论睡眠时间，则取消入睡 + if not is_in_theoretical_sleep: + logger.info("准备入睡期间离开理论休眠时间，取消入睡，恢复清醒。") + self._current_state = SleepState.AWAKE + self._sleep_buffer_end_time = None + self._save_sleep_state() + # 如果缓冲时间结束，则正式进入睡眠状态 + elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time: + logger.info("睡眠缓冲期结束，正式进入休眠状态。") + self._current_state = SleepState.SLEEPING + self._last_fully_slept_log_time = now.timestamp() + + # 设置一个随机的延迟，用于触发“睡后失眠”检查 + delay_minutes_range = global_config.sleep_system.insomnia_trigger_delay_minutes + delay_minutes = random.randint(delay_minutes_range[0], delay_minutes_range[1]) + self._sleep_buffer_end_time = now + timedelta(minutes=delay_minutes) + logger.info(f"已设置睡后失眠检查，将在 {delay_minutes} 分钟后触发。") + + self._save_sleep_state() + + def _handle_sleeping(self, now: datetime, is_in_theoretical_sleep: bool, activity: Optional[str], wakeup_manager: Optional["WakeUpManager"]): + """处理“正在睡觉”状态下的逻辑。""" + # 如果理论睡眠时间结束，则自然醒来 + if not is_in_theoretical_sleep: + logger.info("理论休眠时间结束，自然醒来。") + self._current_state = SleepState.AWAKE + self._save_sleep_state() + # 检查是否到了触发“睡后失眠”的时间点 + elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time: + if wakeup_manager: + sleep_pressure = wakeup_manager.context.sleep_pressure + pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold + # 检查是否触发失眠 + insomnia_reason = None + if sleep_pressure < pressure_threshold: + insomnia_reason = "low_pressure" + logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 低于阈值 ({pressure_threshold})，触发睡后失眠。") + elif random.random() < getattr(global_config.sleep_system, "random_insomnia_chance", 0.1): + insomnia_reason = "random" + logger.info("随机触发失眠。") + + if insomnia_reason: + self._current_state = SleepState.INSOMNIA + + # 设置失眠的持续时间 + duration_minutes_range = global_config.sleep_system.insomnia_duration_minutes + duration_minutes = random.randint(*duration_minutes_range) + self._sleep_buffer_end_time = now + timedelta(minutes=duration_minutes) + + # 发送失眠通知 + asyncio.create_task(NotificationSender.send_insomnia_notification(wakeup_manager.context, insomnia_reason)) + logger.info(f"进入失眠状态 (原因: {insomnia_reason})，将持续 {duration_minutes} 分钟。") + else: + # 睡眠压力正常，不触发失眠，清除检查时间点 + logger.info(f"睡眠压力 ({sleep_pressure:.1f}) 正常，未触发睡后失眠。") + self._sleep_buffer_end_time = None + self._save_sleep_state() + else: + # 定期记录睡眠日志 + current_timestamp = now.timestamp() + if current_timestamp - self.last_sleep_log_time > self.sleep_log_interval and activity: + logger.info(f"当前处于休眠活动 '{activity}' 中。") + self.last_sleep_log_time = current_timestamp + + def _handle_insomnia(self, now: datetime, is_in_theoretical_sleep: bool): + """处理“失眠”状态下的逻辑。""" + # 如果离开理论睡眠时间，则失眠结束 + if not is_in_theoretical_sleep: + logger.info("已离开理论休眠时间，失眠结束，恢复清醒。") + self._current_state = SleepState.AWAKE + self._sleep_buffer_end_time = None + self._save_sleep_state() + # 如果失眠持续时间已过，则恢复睡眠 + elif self._sleep_buffer_end_time and now >= self._sleep_buffer_end_time: + logger.info("失眠状态持续时间已过，恢复睡眠。") + self._current_state = SleepState.SLEEPING + self._sleep_buffer_end_time = None + self._save_sleep_state() + + def _handle_woken_up(self, now: datetime, is_in_theoretical_sleep: bool, wakeup_manager: Optional["WakeUpManager"]): + """处理“被吵醒”状态下的逻辑。""" + # 如果理论睡眠时间结束，则状态自动结束 + if not is_in_theoretical_sleep: + logger.info("理论休眠时间结束，被吵醒的状态自动结束。") + self._current_state = SleepState.AWAKE + self._re_sleep_attempt_time = None + self._save_sleep_state() + # 到了尝试重新入睡的时间点 + elif self._re_sleep_attempt_time and now >= self._re_sleep_attempt_time: + logger.info("被吵醒后经过一段时间，尝试重新入睡...") + if wakeup_manager: + sleep_pressure = wakeup_manager.context.sleep_pressure + pressure_threshold = global_config.sleep_system.flexible_sleep_pressure_threshold + + # 如果睡眠压力足够，则尝试重新入睡 + if sleep_pressure >= pressure_threshold: + logger.info("睡眠压力足够，从被吵醒状态转换到准备入睡。") + buffer_seconds = random.randint(3 * 60, 8 * 60) + self._sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self._current_state = SleepState.PREPARING_SLEEP + self._re_sleep_attempt_time = None + else: + # 睡眠压力不足，延迟一段时间后再次尝试 + delay_minutes = 15 + self._re_sleep_attempt_time = now + timedelta(minutes=delay_minutes) + logger.info( + f"睡眠压力({sleep_pressure:.1f})仍然较低，暂时保持清醒，在 {delay_minutes} 分钟后再次尝试。" + ) + self._save_sleep_state() + + def reset_sleep_state_after_wakeup(self): + """ + 当角色被用户消息等外部因素唤醒时调用此方法。 + 将状态强制转换为 WOKEN_UP，并设置一个延迟，之后会尝试重新入睡。 + """ + if self._current_state in [SleepState.PREPARING_SLEEP, SleepState.SLEEPING, SleepState.INSOMNIA]: + logger.info("被唤醒，进入 WOKEN_UP 状态！") + self._current_state = SleepState.WOKEN_UP + self._sleep_buffer_end_time = None + re_sleep_delay_minutes = getattr(global_config.sleep_system, "re_sleep_delay_minutes", 10) + self._re_sleep_attempt_time = datetime.now() + timedelta(minutes=re_sleep_delay_minutes) + logger.info(f"将在 {re_sleep_delay_minutes} 分钟后尝试重新入睡。") + self._save_sleep_state() + + def _save_sleep_state(self): + """将当前所有睡眠相关的状态打包并保存到本地存储。""" + state_data = { + "_current_state": self._current_state, + "_sleep_buffer_end_time": self._sleep_buffer_end_time, + "_total_delayed_minutes_today": self._total_delayed_minutes_today, + "_last_sleep_check_date": self._last_sleep_check_date, + "_re_sleep_attempt_time": self._re_sleep_attempt_time, + } + SleepStateSerializer.save(state_data) + + def _load_sleep_state(self): + """从本地存储加载并恢复所有睡眠相关的状态。""" + state_data = SleepStateSerializer.load() + self._current_state = state_data["_current_state"] + self._sleep_buffer_end_time = state_data["_sleep_buffer_end_time"] + self._total_delayed_minutes_today = state_data["_total_delayed_minutes_today"] + self._last_sleep_check_date = state_data["_last_sleep_check_date"] + self._re_sleep_attempt_time = state_data["_re_sleep_attempt_time"] diff --git a/src/chat/message_manager/sleep_manager/sleep_state.py b/src/chat/message_manager/sleep_manager/sleep_state.py new file mode 100644 index 000000000..624521ea0 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/sleep_state.py @@ -0,0 +1,110 @@ +from enum import Enum, auto +from datetime import datetime +from src.common.logger import get_logger +from src.manager.local_store_manager import local_storage + +logger = get_logger("sleep_state") + + +class SleepState(Enum): + """ + 定义了角色可能处于的几种睡眠状态。 + 这是一个状态机，用于管理角色的睡眠周期。 + """ + + AWAKE = auto() # 清醒状态 + INSOMNIA = auto() # 失眠状态 + PREPARING_SLEEP = auto() # 准备入睡状态，一个短暂的过渡期 + SLEEPING = auto() # 正在睡觉状态 + WOKEN_UP = auto() # 被吵醒状态 + + +class SleepStateSerializer: + """ + 睡眠状态序列化器。 + 负责将内存中的睡眠状态对象持久化到本地存储（如JSON文件）， + 以及在程序启动时从本地存储中恢复状态。 + 这样可以确保即使程序重启，角色的睡眠状态也能得以保留。 + """ + @staticmethod + def save(state_data: dict): + """ + 将当前的睡眠状态数据保存到本地存储。 + + Args: + state_data (dict): 包含睡眠状态信息的字典。 + datetime对象会被转换为时间戳，Enum成员会被转换为其名称字符串。 + """ + try: + # 准备要序列化的数据字典 + state = { + # 保存当前状态的枚举名称 + "current_state": state_data["_current_state"].name, + # 将datetime对象转换为Unix时间戳以便序列化 + "sleep_buffer_end_time_ts": state_data["_sleep_buffer_end_time"].timestamp() + if state_data["_sleep_buffer_end_time"] + else None, + "total_delayed_minutes_today": state_data["_total_delayed_minutes_today"], + # 将date对象转换为ISO格式的字符串 + "last_sleep_check_date_str": state_data["_last_sleep_check_date"].isoformat() + if state_data["_last_sleep_check_date"] + else None, + "re_sleep_attempt_time_ts": state_data["_re_sleep_attempt_time"].timestamp() + if state_data["_re_sleep_attempt_time"] + else None, + } + # 写入本地存储 + local_storage["schedule_sleep_state"] = state + logger.debug(f"已保存睡眠状态: {state}") + except Exception as e: + logger.error(f"保存睡眠状态失败: {e}") + + @staticmethod + def load() -> dict: + """ + 从本地存储加载并解析睡眠状态。 + + Returns: + dict: 包含恢复后睡眠状态信息的字典。 + 如果加载失败或没有找到数据，则返回一个默认的清醒状态。 + """ + # 定义一个默认的状态，以防加载失败 + state_data = { + "_current_state": SleepState.AWAKE, + "_sleep_buffer_end_time": None, + "_total_delayed_minutes_today": 0, + "_last_sleep_check_date": None, + "_re_sleep_attempt_time": None, + } + try: + # 从本地存储读取数据 + state = local_storage["schedule_sleep_state"] + if state and isinstance(state, dict): + # 恢复当前状态枚举 + state_name = state.get("current_state") + if state_name and hasattr(SleepState, state_name): + state_data["_current_state"] = SleepState[state_name] + + # 从时间戳恢复datetime对象 + end_time_ts = state.get("sleep_buffer_end_time_ts") + if end_time_ts: + state_data["_sleep_buffer_end_time"] = datetime.fromtimestamp(end_time_ts) + + # 恢复重新入睡尝试时间 + re_sleep_ts = state.get("re_sleep_attempt_time_ts") + if re_sleep_ts: + state_data["_re_sleep_attempt_time"] = datetime.fromtimestamp(re_sleep_ts) + + # 恢复今日延迟睡眠总分钟数 + state_data["_total_delayed_minutes_today"] = state.get("total_delayed_minutes_today", 0) + + # 从ISO格式字符串恢复date对象 + date_str = state.get("last_sleep_check_date_str") + if date_str: + state_data["_last_sleep_check_date"] = datetime.fromisoformat(date_str).date() + + logger.info(f"成功从本地存储加载睡眠状态: {state}") + except Exception as e: + # 如果加载过程中出现任何问题，记录警告并返回默认状态 + logger.warning(f"加载睡眠状态失败，将使用默认值: {e}") + return state_data \ No newline at end of file diff --git a/src/chat/message_manager/sleep_manager/time_checker.py b/src/chat/message_manager/sleep_manager/time_checker.py new file mode 100644 index 000000000..47376ac35 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/time_checker.py @@ -0,0 +1,109 @@ +from datetime import datetime, time, timedelta +from typing import Optional, List, Dict, Any +import random + +from src.common.logger import get_logger +from src.config.config import global_config +from src.schedule.schedule_manager import schedule_manager + +logger = get_logger("time_checker") + + +class TimeChecker: + def __init__(self): + # 缓存当天的偏移量，确保一天内使用相同的偏移量 + self._daily_sleep_offset: int = 0 + self._daily_wake_offset: int = 0 + self._offset_date = None + + def _get_daily_offsets(self): + """获取当天的睡眠和起床时间偏移量，每天生成一次""" + today = datetime.now().date() + + # 如果是新的一天，重新生成偏移量 + if self._offset_date != today: + sleep_offset_range = global_config.sleep_system.sleep_time_offset_minutes + wake_offset_range = global_config.sleep_system.wake_up_time_offset_minutes + + # 生成 ±offset_range 范围内的随机偏移量 + self._daily_sleep_offset = random.randint(-sleep_offset_range, sleep_offset_range) + self._daily_wake_offset = random.randint(-wake_offset_range, wake_offset_range) + self._offset_date = today + + logger.debug(f"生成新的每日偏移量 - 睡觉时间偏移: {self._daily_sleep_offset}分钟, 起床时间偏移: {self._daily_wake_offset}分钟") + + return self._daily_sleep_offset, self._daily_wake_offset + + @staticmethod + def get_today_schedule() -> Optional[List[Dict[str, Any]]]: + """从全局 ScheduleManager 获取今天的日程安排。""" + return schedule_manager.today_schedule + + def is_in_theoretical_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]: + if global_config.sleep_system.sleep_by_schedule: + if self.get_today_schedule(): + return self._is_in_schedule_sleep_time(now_time) + else: + return self._is_in_sleep_time(now_time) + else: + return self._is_in_sleep_time(now_time) + + def _is_in_schedule_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]: + """检查当前时间是否落在日程表的任何一个睡眠活动中""" + sleep_keywords = ["休眠", "睡觉", "梦乡"] + today_schedule = self.get_today_schedule() + if today_schedule: + for event in today_schedule: + try: + activity = event.get("activity", "").strip() + time_range = event.get("time_range") + + if not activity or not time_range: + continue + + if any(keyword in activity for keyword in sleep_keywords): + start_str, end_str = time_range.split("-") + start_time = datetime.strptime(start_str.strip(), "%H:%M").time() + end_time = datetime.strptime(end_str.strip(), "%H:%M").time() + + if start_time <= end_time: # 同一天 + if start_time <= now_time < end_time: + return True, activity + else: # 跨天 + if now_time >= start_time or now_time < end_time: + return True, activity + except (ValueError, KeyError, AttributeError) as e: + logger.warning(f"解析日程事件时出错: {event}, 错误: {e}") + continue + return False, None + + def _is_in_sleep_time(self, now_time: time) -> tuple[bool, Optional[str]]: + """检查当前时间是否在固定的睡眠时间内（应用偏移量）""" + try: + start_time_str = global_config.sleep_system.fixed_sleep_time + end_time_str = global_config.sleep_system.fixed_wake_up_time + + # 获取当天的偏移量 + sleep_offset, wake_offset = self._get_daily_offsets() + + # 解析基础时间 + base_start_time = datetime.strptime(start_time_str, "%H:%M") + base_end_time = datetime.strptime(end_time_str, "%H:%M") + + # 应用偏移量 + actual_start_time = (base_start_time + timedelta(minutes=sleep_offset)).time() + actual_end_time = (base_end_time + timedelta(minutes=wake_offset)).time() + + logger.debug(f"固定睡眠时间检查 - 基础时间: {start_time_str}-{end_time_str}, " + f"偏移后时间: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')}, " + f"当前时间: {now_time.strftime('%H:%M')}") + + if actual_start_time <= actual_end_time: + if actual_start_time <= now_time < actual_end_time: + return True, f"固定睡眠时间(偏移后: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')})" + else: + if now_time >= actual_start_time or now_time < actual_end_time: + return True, f"固定睡眠时间(偏移后: {actual_start_time.strftime('%H:%M')}-{actual_end_time.strftime('%H:%M')})" + except ValueError as e: + logger.error(f"固定的睡眠时间格式不正确，请使用 HH:MM 格式: {e}") + return False, None \ No newline at end of file diff --git a/src/chat/message_manager/sleep_manager/wakeup_manager.py b/src/chat/message_manager/sleep_manager/wakeup_manager.py new file mode 100644 index 000000000..a14c77758 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/wakeup_manager.py @@ -0,0 +1,230 @@ +import asyncio +import time +from typing import Optional, TYPE_CHECKING +from src.common.logger import get_logger +from src.config.config import global_config +from src.manager.local_store_manager import local_storage + +if TYPE_CHECKING: + from .sleep_manager import SleepManager + + +logger = get_logger("wakeup") + + +class WakeUpManager: + def __init__(self, sleep_manager: "SleepManager"): + """ + 初始化唤醒度管理器 + + Args: + sleep_manager: 睡眠管理器实例 + + 功能说明: + - 管理休眠状态下的唤醒度累积 + - 处理唤醒度的自然衰减 + - 控制愤怒状态的持续时间 + """ + self.sleep_manager = sleep_manager + self.wakeup_value = 0.0 # 当前唤醒度 + self.is_angry = False # 是否处于愤怒状态 + self.angry_start_time = 0.0 # 愤怒状态开始时间 + self.last_decay_time = time.time() # 上次衰减时间 + self._decay_task: Optional[asyncio.Task] = None + self.is_running = False + self.last_log_time = 0 + self.log_interval = 30 + + # 从配置文件获取参数 + sleep_config = global_config.sleep_system + self.wakeup_threshold = sleep_config.wakeup_threshold + self.private_message_increment = sleep_config.private_message_increment + self.group_mention_increment = sleep_config.group_mention_increment + self.decay_rate = sleep_config.decay_rate + self.decay_interval = sleep_config.decay_interval + self.angry_duration = sleep_config.angry_duration + self.enabled = sleep_config.enable + self.angry_prompt = sleep_config.angry_prompt + + self._load_wakeup_state() + + def _get_storage_key(self) -> str: + """获取本地存储键""" + return "global_wakeup_manager_state" + + def _load_wakeup_state(self): + """从本地存储加载状态""" + state = local_storage[self._get_storage_key()] + if state and isinstance(state, dict): + self.wakeup_value = state.get("wakeup_value", 0.0) + self.is_angry = state.get("is_angry", False) + self.angry_start_time = state.get("angry_start_time", 0.0) + logger.info(f"成功从本地存储加载唤醒状态: {state}") + else: + logger.info("未找到本地唤醒状态，将使用默认值初始化。") + + def _save_wakeup_state(self): + """将当前状态保存到本地存储""" + state = { + "wakeup_value": self.wakeup_value, + "is_angry": self.is_angry, + "angry_start_time": self.angry_start_time, + } + local_storage[self._get_storage_key()] = state + logger.debug(f"已将唤醒状态保存到本地存储: {state}") + + async def start(self): + """启动唤醒度管理器""" + if not self.enabled: + logger.info("唤醒度系统已禁用，跳过启动") + return + + self.is_running = True + if not self._decay_task or self._decay_task.done(): + self._decay_task = asyncio.create_task(self._decay_loop()) + self._decay_task.add_done_callback(self._handle_decay_completion) + logger.info("唤醒度管理器已启动") + + async def stop(self): + """停止唤醒度管理器""" + self.is_running = False + if self._decay_task and not self._decay_task.done(): + self._decay_task.cancel() + await asyncio.sleep(0) + logger.info("唤醒度管理器已停止") + + def _handle_decay_completion(self, task: asyncio.Task): + """处理衰减任务完成""" + try: + if exception := task.exception(): + logger.error(f"唤醒度衰减任务异常: {exception}") + else: + logger.info("唤醒度衰减任务正常结束") + except asyncio.CancelledError: + logger.info("唤醒度衰减任务被取消") + + async def _decay_loop(self): + """唤醒度衰减循环""" + while self.is_running: + await asyncio.sleep(self.decay_interval) + + current_time = time.time() + + # 检查愤怒状态是否过期 + if self.is_angry and current_time - self.angry_start_time >= self.angry_duration: + self.is_angry = False + # 通知情绪管理系统清除愤怒状态 + from src.mood.mood_manager import mood_manager + mood_manager.clear_angry_from_wakeup("global_mood") + logger.info("愤怒状态结束，恢复正常") + self._save_wakeup_state() + + # 唤醒度自然衰减 + if self.wakeup_value > 0: + old_value = self.wakeup_value + self.wakeup_value = max(0, self.wakeup_value - self.decay_rate) + if old_value != self.wakeup_value: + logger.debug(f"唤醒度衰减: {old_value:.1f} -> {self.wakeup_value:.1f}") + self._save_wakeup_state() + + def add_wakeup_value(self, is_private_chat: bool, is_mentioned: bool = False) -> bool: + """ + 增加唤醒度值 + + Args: + is_private_chat: 是否为私聊 + is_mentioned: 是否被艾特(仅群聊有效) + + Returns: + bool: 是否达到唤醒阈值 + """ + # 如果系统未启用，直接返回 + if not self.enabled: + return False + + # 只有在休眠且非失眠状态下才累积唤醒度 + from .sleep_state import SleepState + + current_sleep_state = self.sleep_manager.get_current_sleep_state() + if current_sleep_state != SleepState.SLEEPING: + return False + + old_value = self.wakeup_value + + if is_private_chat: + # 私聊每条消息都增加唤醒度 + self.wakeup_value += self.private_message_increment + logger.debug(f"私聊消息增加唤醒度: +{self.private_message_increment}") + elif is_mentioned: + # 群聊只有被艾特才增加唤醒度 + self.wakeup_value += self.group_mention_increment + logger.debug(f"群聊艾特增加唤醒度: +{self.group_mention_increment}") + else: + # 群聊未被艾特，不增加唤醒度 + return False + + current_time = time.time() + if current_time - self.last_log_time > self.log_interval: + logger.info( + f"唤醒度变化: {old_value:.1f} -> {self.wakeup_value:.1f} (阈值: {self.wakeup_threshold})" + ) + self.last_log_time = current_time + else: + logger.debug( + f"唤醒度变化: {old_value:.1f} -> {self.wakeup_value:.1f} (阈值: {self.wakeup_threshold})" + ) + + # 检查是否达到唤醒阈值 + if self.wakeup_value >= self.wakeup_threshold: + self._trigger_wakeup() + return True + + self._save_wakeup_state() + return False + + def _trigger_wakeup(self): + """触发唤醒，进入愤怒状态""" + self.is_angry = True + self.angry_start_time = time.time() + self.wakeup_value = 0.0 # 重置唤醒度 + + self._save_wakeup_state() + + # 通知情绪管理系统进入愤怒状态 + from src.mood.mood_manager import mood_manager + mood_manager.set_angry_from_wakeup("global_mood") + + # 通知SleepManager重置睡眠状态 + self.sleep_manager.reset_sleep_state_after_wakeup() + + logger.info(f"唤醒度达到阈值({self.wakeup_threshold})，被吵醒进入愤怒状态！") + + def get_angry_prompt_addition(self) -> str: + """获取愤怒状态下的提示词补充""" + if self.is_angry: + return self.angry_prompt + return "" + + def is_in_angry_state(self) -> bool: + """检查是否处于愤怒状态""" + if self.is_angry: + current_time = time.time() + if current_time - self.angry_start_time >= self.angry_duration: + self.is_angry = False + # 通知情绪管理系统清除愤怒状态 + from src.mood.mood_manager import mood_manager + mood_manager.clear_angry_from_wakeup("global_mood") + logger.info("愤怒状态自动过期") + return False + return self.is_angry + + def get_status_info(self) -> dict: + """获取当前状态信息""" + return { + "wakeup_value": self.wakeup_value, + "wakeup_threshold": self.wakeup_threshold, + "is_angry": self.is_angry, + "angry_remaining_time": max(0, self.angry_duration - (time.time() - self.angry_start_time)) + if self.is_angry + else 0, + }