From 0510ce9d55732f48492336539438d57f257155d0 Mon Sep 17 00:00:00 2001 From: minecraft1024a Date: Fri, 17 Oct 2025 18:44:38 +0800 Subject: [PATCH] =?UTF-8?q?Revert=20"=E5=AE=9E=E7=8E=B0=E4=BA=86=E6=96=B0?= =?UTF-8?q?=E7=9A=84=E7=9D=A1=E7=9C=A0=E7=B3=BB=E7=BB=9F=E5=96=B5~",?= =?UTF-8?q?=E6=88=91=E7=9C=8B=E4=BA=86=E4=B8=8D=E5=A6=82=E6=88=91=E5=9B=9E?= =?UTF-8?q?=E5=8E=BB=E8=87=AA=E5=B7=B1=E5=86=99=E4=B8=80=E4=B8=AA()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit e1dde64fc66887dcc0ecf846978879c29cec4137. --- src/chat/message_manager/message_manager.py | 33 +- .../sleep_manager/notification_sender.py | 33 ++ .../sleep_manager/sleep_manager.py | 291 ++++++++++++++++++ .../sleep_manager/sleep_state.py | 86 ++++++ .../sleep_manager/time_checker.py | 119 +++++++ .../sleep_manager/wakeup_context.py | 45 +++ .../sleep_manager/wakeup_manager.py | 218 +++++++++++++ src/plugins/built_in/sleep_system/__init__.py | 49 --- src/plugins/built_in/sleep_system/api.py | 9 - src/plugins/built_in/sleep_system/config.py | 18 -- src/plugins/built_in/sleep_system/py.typed | 2 - .../built_in/sleep_system/sleep_logic.py | 134 -------- .../built_in/sleep_system/state_manager.py | 83 ----- src/plugins/built_in/sleep_system/tasks.py | 48 --- 14 files changed, 804 insertions(+), 364 deletions(-) create mode 100644 src/chat/message_manager/sleep_manager/notification_sender.py create mode 100644 src/chat/message_manager/sleep_manager/sleep_manager.py create mode 100644 src/chat/message_manager/sleep_manager/sleep_state.py create mode 100644 src/chat/message_manager/sleep_manager/time_checker.py create mode 100644 src/chat/message_manager/sleep_manager/wakeup_context.py create mode 100644 src/chat/message_manager/sleep_manager/wakeup_manager.py delete mode 100644 src/plugins/built_in/sleep_system/__init__.py delete mode 100644 src/plugins/built_in/sleep_system/api.py delete mode 100644 src/plugins/built_in/sleep_system/config.py delete mode 100644 src/plugins/built_in/sleep_system/py.typed delete mode 100644 src/plugins/built_in/sleep_system/sleep_logic.py delete mode 100644 src/plugins/built_in/sleep_system/state_manager.py delete mode 100644 src/plugins/built_in/sleep_system/tasks.py diff --git a/src/chat/message_manager/message_manager.py b/src/chat/message_manager/message_manager.py index 17c3b02c1..70afbcfa8 100644 --- a/src/chat/message_manager/message_manager.py +++ b/src/chat/message_manager/message_manager.py @@ -17,11 +17,10 @@ from src.common.data_models.message_manager_data_model import MessageManagerStat from src.common.logger import get_logger from src.config.config import global_config from src.plugin_system.apis.chat_api import get_chat_manager -from src.plugins.built_in.sleep_system.api import on_message_received from .distribution_manager import stream_loop_manager -# from .sleep_manager.sleep_manager import SleepManager -# from .sleep_manager.wakeup_manager import WakeUpManager +from .sleep_manager.sleep_manager import SleepManager +from .sleep_manager.wakeup_manager import WakeUpManager if TYPE_CHECKING: pass @@ -44,9 +43,9 @@ class MessageManager: self.action_manager = ChatterActionManager() self.chatter_manager = ChatterManager(self.action_manager) - # 初始化睡眠和唤醒管理器 (已被新插件取代) - # self.sleep_manager = SleepManager() - # self.wakeup_manager = WakeUpManager(self.sleep_manager) + # 初始化睡眠和唤醒管理器 + self.sleep_manager = SleepManager() + self.wakeup_manager = WakeUpManager(self.sleep_manager) # 消息缓存系统 - 直接集成到消息管理器 self.message_caches: Dict[str, deque] = defaultdict(deque) # 每个流的消息缓存 @@ -94,8 +93,8 @@ class MessageManager: except Exception as e: logger.error(f"启动自适应流管理器失败: {e}") - # 启动睡眠和唤醒管理器 (已被新插件取代) - # await self.wakeup_manager.start() + # 启动睡眠和唤醒管理器 + await self.wakeup_manager.start() # 启动流循环管理器并设置chatter_manager await stream_loop_manager.start() @@ -142,8 +141,8 @@ class MessageManager: except Exception as e: logger.error(f"停止自适应流管理器失败: {e}") - # 停止睡眠和唤醒管理器 (已被新插件取代) - # await self.wakeup_manager.stop() + # 停止睡眠和唤醒管理器 + await self.wakeup_manager.stop() # 停止流循环管理器 await stream_loop_manager.stop() @@ -153,9 +152,6 @@ class MessageManager: async def add_message(self, stream_id: str, message: DatabaseMessages): """添加消息到指定聊天流""" try: - # 触发睡眠系统外部事件 - on_message_received() - chat_manager = get_chat_manager() chat_stream = await chat_manager.get_stream(stream_id) if not chat_stream: @@ -339,14 +335,9 @@ class MessageManager: inactive_streams.append(stream_id) for stream_id in inactive_streams: try: - # 修复: 直接通过 stream_id 获取 chat_stream，避免潜在的未绑定问题 - inactive_stream = chat_manager.streams.get(stream_id) - if inactive_stream: - await inactive_stream.context_manager.clear_context() - del chat_manager.streams[stream_id] - logger.info(f"清理不活跃聊天流: {stream_id}") - else: - logger.warning(f"尝试清理一个不存在的流: {stream_id}") + await chat_stream.context_manager.clear_context() + del chat_manager.streams[stream_id] + logger.info(f"清理不活跃聊天流: {stream_id}") except Exception as e: logger.error(f"清理聊天流 {stream_id} 失败: {e}") if inactive_streams: 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..d40cd612d --- /dev/null +++ b/src/chat/message_manager/sleep_manager/notification_sender.py @@ -0,0 +1,33 @@ +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): # type: ignore + """发送晚安通知""" + # 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, reason: str): # type: ignore + """发送失眠通知""" + # 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}") 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..6aeab8037 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/sleep_manager.py @@ -0,0 +1,291 @@ +import asyncio +import random +from datetime import datetime, timedelta +from typing import TYPE_CHECKING, Optional + +from src.common.logger import get_logger +from src.config.config import global_config + +from .notification_sender import NotificationSender +from .sleep_state import SleepContext, SleepState +from .time_checker import TimeChecker + +if TYPE_CHECKING: + from .wakeup_manager import WakeUpManager + +logger = get_logger("sleep_manager") + + +class SleepManager: + """ + 睡眠管理器，核心组件之一，负责管理角色的睡眠周期和状态转换。 + 它实现了一个状态机，根据预设的时间表、睡眠压力和随机因素， + 在不同的睡眠状态（如清醒、准备入睡、睡眠、失眠）之间进行切换。 + """ + + def __init__(self): + """ + 初始化睡眠管理器。 + """ + self.context = SleepContext() # 睡眠上下文，管理所有状态 + self.time_checker = TimeChecker() # 时间检查器 + self.last_sleep_log_time = 0 # 上次记录睡眠日志的时间戳 + self.sleep_log_interval = 35 # 睡眠日志记录间隔（秒） + self._last_fully_slept_log_time: float = 0 # 上次完全进入睡眠状态的时间戳 + + def get_current_sleep_state(self) -> SleepState: + """获取当前的睡眠状态。""" + return self.context.current_state + + def is_sleeping(self) -> bool: + """判断当前是否处于正在睡觉的状态。""" + return self.context.current_state == SleepState.SLEEPING + + def is_woken_up(self) -> bool: + """判断当前是否处于被吵醒的状态。""" + return self.context.current_state == SleepState.WOKEN_UP + + 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.context.current_state != SleepState.AWAKE: + logger.debug("睡眠系统禁用，强制设为 AWAKE") + self.context.current_state = SleepState.AWAKE + return + + now = datetime.now() + today = now.date() + + # 跨天处理：如果日期变化，重置每日相关的睡眠状态 + if self.context.last_sleep_check_date != today: + logger.info(f"新的一天 ({today})，重置睡眠状态。") + self.context.total_delayed_minutes_today = 0 + self.context.current_state = SleepState.AWAKE + self.context.sleep_buffer_end_time = None + self.context.last_sleep_check_date = today + self.context.save() + + # 检查当前是否处于理论上的睡眠时间段 + is_in_theoretical_sleep, activity = self.time_checker.is_in_theoretical_sleep_time(now.time()) + + # --- 状态机核心处理逻辑 --- + current_state = self.context.current_state + if current_state == SleepState.AWAKE: + if is_in_theoretical_sleep: + self._handle_awake_to_sleep(now, activity, wakeup_manager) + + elif current_state == SleepState.PREPARING_SLEEP: + self._handle_preparing_sleep(now, is_in_theoretical_sleep, wakeup_manager) + + elif current_state == SleepState.SLEEPING: + self._handle_sleeping(now, is_in_theoretical_sleep, activity, wakeup_manager) + + elif current_state == SleepState.INSOMNIA: + self._handle_insomnia(now, is_in_theoretical_sleep) + + elif 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: str | None, 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.context.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.context.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.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self.context.current_state = SleepState.PREPARING_SLEEP + logger.info(f"进入准备入睡状态，将在 {buffer_seconds / 60:.1f} 分钟内入睡。") + self.context.save() + else: + # 无法获取 wakeup_manager，退回旧逻辑 + buffer_seconds = random.randint(1 * 60, 3 * 60) + self.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self.context.current_state = SleepState.PREPARING_SLEEP + logger.warning("无法获取 WakeUpManager，弹性睡眠采用默认1-3分钟延迟。") + self.context.save() + else: + # 非弹性睡眠模式 + if wakeup_manager and global_config.sleep_system.enable_pre_sleep_notification: + asyncio.create_task(NotificationSender.send_goodnight_notification(wakeup_manager.context)) + self.context.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.context.current_state = SleepState.AWAKE + self.context.sleep_buffer_end_time = None + self.context.save() + # 如果缓冲时间结束，则正式进入睡眠状态 + elif self.context.sleep_buffer_end_time and now >= self.context.sleep_buffer_end_time: + logger.info("睡眠缓冲期结束，正式进入休眠状态。") + self.context.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.context.sleep_buffer_end_time = now + timedelta(minutes=delay_minutes) + logger.info(f"已设置睡后失眠检查，将在 {delay_minutes} 分钟后触发。") + + self.context.save() + + def _handle_sleeping( + self, + now: datetime, + is_in_theoretical_sleep: bool, + activity: str | None, + wakeup_manager: Optional["WakeUpManager"], + ): + """处理“正在睡觉”状态下的逻辑。""" + # 如果理论睡眠时间结束，则自然醒来 + if not is_in_theoretical_sleep: + logger.info("理论休眠时间结束，自然醒来。") + self.context.current_state = SleepState.AWAKE + self.context.save() + # 检查是否到了触发“睡后失眠”的时间点 + elif self.context.sleep_buffer_end_time and now >= self.context.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.context.current_state = SleepState.INSOMNIA + + # 设置失眠的持续时间 + duration_minutes_range = global_config.sleep_system.insomnia_duration_minutes + duration_minutes = random.randint(*duration_minutes_range) + self.context.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.context.sleep_buffer_end_time = None + self.context.save() + 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.context.current_state = SleepState.AWAKE + self.context.sleep_buffer_end_time = None + self.context.save() + # 如果失眠持续时间已过，则恢复睡眠 + elif self.context.sleep_buffer_end_time and now >= self.context.sleep_buffer_end_time: + logger.info("失眠状态持续时间已过，恢复睡眠。") + self.context.current_state = SleepState.SLEEPING + self.context.sleep_buffer_end_time = None + self.context.save() + + 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.context.current_state = SleepState.AWAKE + self.context.re_sleep_attempt_time = None + self.context.save() + # 到了尝试重新入睡的时间点 + elif self.context.re_sleep_attempt_time and now >= self.context.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.context.sleep_buffer_end_time = now + timedelta(seconds=buffer_seconds) + self.context.current_state = SleepState.PREPARING_SLEEP + self.context.re_sleep_attempt_time = None + else: + # 睡眠压力不足，延迟一段时间后再次尝试 + delay_minutes = 15 + self.context.re_sleep_attempt_time = now + timedelta(minutes=delay_minutes) + logger.info( + f"睡眠压力({sleep_pressure:.1f})仍然较低，暂时保持清醒，在 {delay_minutes} 分钟后再次尝试。" + ) + self.context.save() + + def reset_sleep_state_after_wakeup(self): + """ + 当角色被用户消息等外部因素唤醒时调用此方法。 + 将状态强制转换为 WOKEN_UP，并设置一个延迟，之后会尝试重新入睡。 + """ + if self.context.current_state in [SleepState.PREPARING_SLEEP, SleepState.SLEEPING, SleepState.INSOMNIA]: + logger.info("被唤醒，进入 WOKEN_UP 状态！") + self.context.current_state = SleepState.WOKEN_UP + self.context.sleep_buffer_end_time = None + re_sleep_delay_minutes = getattr(global_config.sleep_system, "re_sleep_delay_minutes", 10) + self.context.re_sleep_attempt_time = datetime.now() + timedelta(minutes=re_sleep_delay_minutes) + logger.info(f"将在 {re_sleep_delay_minutes} 分钟后尝试重新入睡。") + self.context.save() 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..21a9f11bb --- /dev/null +++ b/src/chat/message_manager/sleep_manager/sleep_state.py @@ -0,0 +1,86 @@ +from datetime import date, datetime +from enum import Enum, auto + +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 SleepContext: + """ + 睡眠上下文，负责封装和管理所有与睡眠相关的状态，并处理其持久化。 + """ + + def __init__(self): + """初始化睡眠上下文，并从本地存储加载初始状态。""" + self.current_state: SleepState = SleepState.AWAKE + self.sleep_buffer_end_time: datetime | None = None + self.total_delayed_minutes_today: float = 0.0 + self.last_sleep_check_date: date | None = None + self.re_sleep_attempt_time: datetime | None = None + self.load() + + def save(self): + """将当前的睡眠状态数据保存到本地存储。""" + try: + state = { + "current_state": self.current_state.name, + "sleep_buffer_end_time_ts": self.sleep_buffer_end_time.timestamp() + if self.sleep_buffer_end_time + else None, + "total_delayed_minutes_today": self.total_delayed_minutes_today, + "last_sleep_check_date_str": self.last_sleep_check_date.isoformat() + if self.last_sleep_check_date + else None, + "re_sleep_attempt_time_ts": self.re_sleep_attempt_time.timestamp() + if self.re_sleep_attempt_time + else None, + } + local_storage["schedule_sleep_state"] = state + logger.debug(f"已保存睡眠上下文: {state}") + except Exception as e: + logger.error(f"保存睡眠上下文失败: {e}") + + def load(self): + """从本地存储加载并解析睡眠状态。""" + try: + state = local_storage["schedule_sleep_state"] + if not (state and isinstance(state, dict)): + logger.info("未找到本地睡眠上下文，使用默认值。") + return + + state_name = state.get("current_state") + if state_name and hasattr(SleepState, state_name): + self.current_state = SleepState[state_name] + + end_time_ts = state.get("sleep_buffer_end_time_ts") + if end_time_ts: + self.sleep_buffer_end_time = datetime.fromtimestamp(end_time_ts) + + re_sleep_ts = state.get("re_sleep_attempt_time_ts") + if re_sleep_ts: + self.re_sleep_attempt_time = datetime.fromtimestamp(re_sleep_ts) + + self.total_delayed_minutes_today = state.get("total_delayed_minutes_today", 0.0) + + date_str = state.get("last_sleep_check_date_str") + if date_str: + self.last_sleep_check_date = datetime.fromisoformat(date_str).date() + + logger.info(f"成功从本地存储加载睡眠上下文: {state}") + except Exception as e: + logger.warning(f"加载睡眠上下文失败，将使用默认值: {e}") 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..0ea099039 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/time_checker.py @@ -0,0 +1,119 @@ +import random +from datetime import datetime, time, timedelta +from typing import Any + +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() -> list[dict[str, Any]] | None: + """从全局 ScheduleManager 获取今天的日程安排。""" + return schedule_manager.today_schedule + + def is_in_theoretical_sleep_time(self, now_time: time) -> tuple[bool, str | None]: + 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, str | None]: + """检查当前时间是否落在日程表的任何一个睡眠活动中""" + 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, str | None]: + """检查当前时间是否在固定的睡眠时间内（应用偏移量）""" + 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 diff --git a/src/chat/message_manager/sleep_manager/wakeup_context.py b/src/chat/message_manager/sleep_manager/wakeup_context.py new file mode 100644 index 000000000..efb59e392 --- /dev/null +++ b/src/chat/message_manager/sleep_manager/wakeup_context.py @@ -0,0 +1,45 @@ +from src.common.logger import get_logger +from src.manager.local_store_manager import local_storage + +logger = get_logger("wakeup_context") + + +class WakeUpContext: + """ + 唤醒上下文，负责封装和管理所有与唤醒相关的状态，并处理其持久化。 + """ + + def __init__(self): + """初始化唤醒上下文，并从本地存储加载初始状态。""" + self.wakeup_value: float = 0.0 + self.is_angry: bool = False + self.angry_start_time: float = 0.0 + self.sleep_pressure: float = 100.0 # 新增：睡眠压力 + self.load() + + def _get_storage_key(self) -> str: + """获取本地存储键""" + return "global_wakeup_manager_state" + + def load(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) + self.sleep_pressure = state.get("sleep_pressure", 100.0) + logger.info(f"成功从本地存储加载唤醒上下文: {state}") + else: + logger.info("未找到本地唤醒上下文，将使用默认值初始化。") + + def save(self): + """将当前状态保存到本地存储""" + state = { + "wakeup_value": self.wakeup_value, + "is_angry": self.is_angry, + "angry_start_time": self.angry_start_time, + "sleep_pressure": self.sleep_pressure, + } + local_storage[self._get_storage_key()] = state + logger.debug(f"已将唤醒上下文保存到本地存储: {state}") 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..d390d9d3d --- /dev/null +++ b/src/chat/message_manager/sleep_manager/wakeup_manager.py @@ -0,0 +1,218 @@ +import asyncio +import time +from typing import TYPE_CHECKING + +from src.chat.message_manager.sleep_manager.wakeup_context import WakeUpContext +from src.common.logger import get_logger +from src.config.config import global_config + +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.context = WakeUpContext() # 使用新的上下文管理器 + self.angry_chat_id: str | None = None + self.last_decay_time = time.time() + self._decay_task: asyncio.Task | None = 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 + + 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.context.is_angry and current_time - self.context.angry_start_time >= self.angry_duration: + self.context.is_angry = False + # 通知情绪管理系统清除愤怒状态 + from src.mood.mood_manager import mood_manager + + if self.angry_chat_id: + mood_manager.clear_angry_from_wakeup(self.angry_chat_id) + self.angry_chat_id = None + else: + logger.warning("Angry state ended but no angry_chat_id was set.") + logger.info("愤怒状态结束，恢复正常") + self.context.save() + + # 唤醒度自然衰减 + if self.context.wakeup_value > 0: + old_value = self.context.wakeup_value + self.context.wakeup_value = max(0, self.context.wakeup_value - self.decay_rate) + if old_value != self.context.wakeup_value: + logger.debug(f"唤醒度衰减: {old_value:.1f} -> {self.context.wakeup_value:.1f}") + self.context.save() + + def add_wakeup_value(self, is_private_chat: bool, is_mentioned: bool = False, chat_id: str | None = None) -> 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.context.wakeup_value + + if is_private_chat: + # 私聊每条消息都增加唤醒度 + self.context.wakeup_value += self.private_message_increment + logger.debug(f"私聊消息增加唤醒度: +{self.private_message_increment}") + elif is_mentioned: + # 群聊只有被艾特才增加唤醒度 + self.context.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.context.wakeup_value:.1f} (阈值: {self.wakeup_threshold})" + ) + self.last_log_time = current_time + else: + logger.debug( + f"唤醒度变化: {old_value:.1f} -> {self.context.wakeup_value:.1f} (阈值: {self.wakeup_threshold})" + ) + + # 检查是否达到唤醒阈值 + if self.context.wakeup_value >= self.wakeup_threshold: + if not chat_id: + logger.error("Wakeup threshold reached, but no chat_id was provided. Cannot trigger wakeup.") + return False + self._trigger_wakeup(chat_id) + return True + + self.context.save() + return False + + def _trigger_wakeup(self, chat_id: str): + """触发唤醒，进入愤怒状态""" + self.context.is_angry = True + self.context.angry_start_time = time.time() + self.context.wakeup_value = 0.0 # 重置唤醒度 + self.angry_chat_id = chat_id + + self.context.save() + + # 通知情绪管理系统进入愤怒状态 + from src.mood.mood_manager import mood_manager + + mood_manager.set_angry_from_wakeup(chat_id) + + # 通知SleepManager重置睡眠状态 + self.sleep_manager.reset_sleep_state_after_wakeup() + + logger.info(f"唤醒度达到阈值({self.wakeup_threshold})，被吵醒进入愤怒状态！") + + def get_angry_prompt_addition(self) -> str: + """获取愤怒状态下的提示词补充""" + if self.context.is_angry: + return self.angry_prompt + return "" + + def is_in_angry_state(self) -> bool: + """检查是否处于愤怒状态""" + if self.context.is_angry: + current_time = time.time() + if current_time - self.context.angry_start_time >= self.angry_duration: + self.context.is_angry = False + # 通知情绪管理系统清除愤怒状态 + from src.mood.mood_manager import mood_manager + + if self.angry_chat_id: + mood_manager.clear_angry_from_wakeup(self.angry_chat_id) + self.angry_chat_id = None + else: + logger.warning("Angry state expired in check, but no angry_chat_id was set.") + logger.info("愤怒状态自动过期") + return False + return self.context.is_angry + + def get_status_info(self) -> dict: + """获取当前状态信息""" + return { + "wakeup_value": self.context.wakeup_value, + "wakeup_threshold": self.wakeup_threshold, + "is_angry": self.context.is_angry, + "angry_remaining_time": max(0, self.angry_duration - (time.time() - self.context.angry_start_time)) + if self.context.is_angry + else 0, + } diff --git a/src/plugins/built_in/sleep_system/__init__.py b/src/plugins/built_in/sleep_system/__init__.py deleted file mode 100644 index 6cc5d52ad..000000000 --- a/src/plugins/built_in/sleep_system/__init__.py +++ /dev/null @@ -1,49 +0,0 @@ -import logging -from pathlib import Path -from typing import Optional - -from src.plugin_system import BasePlugin, register_plugin - -from .config import SleepSystemConfig -from .state_manager import StateManager -from .sleep_logic import SleepLogic -from .tasks import SleepCycleTask - -# 日志配置 -logger = logging.getLogger(__name__) - -# 全局任务变量 -sleep_task: Optional[SleepCycleTask] = None -sleep_logic_instance: Optional[SleepLogic] = None - -@register_plugin -class SleepSystemPlugin(BasePlugin): - plugin_name: str = "sleep_system" - - def on_load(self) -> None: - global sleep_task, sleep_logic_instance - logger.info("睡眠系统插件正在加载...") - - # 1. 加载配置 - config = self.get_config(self.plugin_name, SleepSystemConfig) - - # 2. 初始化状态管理器 - state_file = Path(f"data/{self.plugin_name}_state.json") - state_manager = StateManager(state_file_path=state_file) - - # 3. 初始化核心逻辑 - sleep_logic_instance = SleepLogic(config=config, state_manager=state_manager) - - # 4. 初始化并启动定时任务 - sleep_task = SleepCycleTask(sleep_logic=sleep_logic_instance, interval_seconds=30) - sleep_task.start() - - logger.info("睡眠系统插件加载完成，定时任务已启动。") - - def on_unload(self) -> None: - global sleep_task, sleep_logic_instance - logger.info("睡眠系统插件正在卸载...") - if sleep_task: - sleep_task.stop() - sleep_logic_instance = None - logger.info("睡眠系统插件已卸载，定时任务已停止。") diff --git a/src/plugins/built_in/sleep_system/api.py b/src/plugins/built_in/sleep_system/api.py deleted file mode 100644 index f0731dd4f..000000000 --- a/src/plugins/built_in/sleep_system/api.py +++ /dev/null @@ -1,9 +0,0 @@ -import asyncio -from . import sleep_logic_instance - -def on_message_received(): - """ - 当接收到用户消息时调用此函数，用于处理睡眠中断。 - """ - if sleep_logic_instance: - asyncio.create_task(sleep_logic_instance.handle_external_event()) diff --git a/src/plugins/built_in/sleep_system/config.py b/src/plugins/built_in/sleep_system/config.py deleted file mode 100644 index 5c6dcdd92..000000000 --- a/src/plugins/built_in/sleep_system/config.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import Tuple -from pydantic import BaseModel, Field - - -class SleepSystemConfig(BaseModel): - # 睡眠时间段，格式为 (时, 分) - sleep_time: Tuple[int, int] = Field(default=(23, 0), description="每日固定的入睡时间点") - wake_up_time: Tuple[int, int] = Field(default=(7, 0), description="每日固定的唤醒时间点") - - # 睡前准备时间（分钟） - prepare_sleep_duration: int = Field(default=15, ge=5, le=30, description="进入睡眠状态前的准备时间（分钟）") - - # 失眠设置 - insomnia_probability: float = Field(default=0.1, ge=0, le=1, description="在睡眠状态下触发失眠的概率") - insomnia_duration_minutes: Tuple[int, int] = Field(default=(10, 30), description="失眠状态的持续时间范围（分钟）") - - # 被吵醒设置 - woken_up_cooldown_minutes: int = Field(default=10, description="被吵醒后尝试重新入睡的冷却时间（分钟）") \ No newline at end of file diff --git a/src/plugins/built_in/sleep_system/py.typed b/src/plugins/built_in/sleep_system/py.typed deleted file mode 100644 index d3f256c5a..000000000 --- a/src/plugins/built_in/sleep_system/py.typed +++ /dev/null @@ -1,2 +0,0 @@ -# This file is intentionally left empty. -# It is a marker file that tells MyPy to perform type checking on this package. \ No newline at end of file diff --git a/src/plugins/built_in/sleep_system/sleep_logic.py b/src/plugins/built_in/sleep_system/sleep_logic.py deleted file mode 100644 index cd9c33572..000000000 --- a/src/plugins/built_in/sleep_system/sleep_logic.py +++ /dev/null @@ -1,134 +0,0 @@ -import logging -import random -import time -from datetime import datetime, time as dt_time, timedelta -from .config import SleepSystemConfig -from .state_manager import StateManager, SleepState - -logger = logging.getLogger(__name__) - -class SleepLogic: - """ - 实现睡眠系统的核心状态机逻辑。 - """ - def __init__(self, config: SleepSystemConfig, state_manager: StateManager): - self.config = config - self.state_manager = state_manager - - async def update_state(self) -> None: - """ - 核心更新函数，由定时任务调用。 - 根据当前时间和状态，决定是否进行状态转换。 - """ - current_state = await self.state_manager.get_state() - now = datetime.now() - - handler = getattr(self, f"_handle_{current_state.current_state.lower()}", self._handle_unknown) - await handler(current_state, now) - - def _is_in_sleep_time_range(self, now: datetime) -> bool: - """检查当前时间是否在理论睡眠时间范围内""" - wake_up_time = dt_time(self.config.wake_up_time[0], self.config.wake_up_time[1]) - sleep_time = dt_time(self.config.sleep_time[0], self.config.sleep_time[1]) - now_time = now.time() - - if sleep_time > wake_up_time: # 跨天睡眠 - return now_time >= sleep_time or now_time < wake_up_time - else: # 当天睡眠 - return sleep_time <= now_time < wake_up_time - - async def _handle_awake(self, state: SleepState, now: datetime): - """处理 AWAKE 状态的逻辑""" - # 检查是否到了准备睡觉的时间 - sleep_datetime = datetime.combine(now.date(), dt_time(self.config.sleep_time[0], self.config.sleep_time[1])) - prepare_start_time = sleep_datetime - timedelta(minutes=self.config.prepare_sleep_duration) - - if prepare_start_time <= now < sleep_datetime: - await self._transition_to(state, "PREPARING_SLEEP", duration_minutes=self.config.prepare_sleep_duration) - logger.info("时间已到，进入睡前准备状态。") - # 在这里可以触发“准备睡觉”的情绪或回复 - - async def _handle_preparing_sleep(self, state: SleepState, now: datetime): - """处理 PREPARING_SLEEP 状态的逻辑""" - if state.state_end_time and now.timestamp() >= state.state_end_time: - # 准备时间结束，进入睡眠 - if self._is_in_sleep_time_range(now): - await self._transition_to(state, "SLEEPING") - logger.info("准备时间结束，已进入睡眠状态。") - else: - await self._transition_to(state, "AWAKE") - logger.info("准备期间离开了理论睡眠时间，返回 AWAKE 状态。") - - async def _handle_sleeping(self, state: SleepState, now: datetime): - """处理 SLEEPING 状态的逻辑""" - # 检查是否到了起床时间 - if not self._is_in_sleep_time_range(now): - await self._transition_to(state, "AWAKE") - logger.info("理论睡眠时间结束，已切换到 AWAKE 状态。") - # 在这里可以触发“睡醒”的情绪 - return - - # 根据概率随机触发失眠 - if random.random() < self.config.insomnia_probability: - duration = random.randint(self.config.insomnia_duration_minutes[0], self.config.insomnia_duration_minutes[1]) - await self._transition_to(state, "INSOMNIA", duration_minutes=duration) - logger.info(f"随机触发失眠，持续 {duration} 分钟。") - # 在这里可以触发“烦躁”的情绪 - - async def _handle_insomnia(self, state: SleepState, now: datetime): - """处理 INSOMNIA 状态的逻辑""" - # 检查失眠时间是否结束 - if state.state_end_time and now.timestamp() >= state.state_end_time: - await self._transition_to(state, "SLEEPING") - logger.info("失眠时间结束，返回睡眠状态。") - # 如果在失眠期间就到了起床时间，直接唤醒 - elif not self._is_in_sleep_time_range(now): - await self._transition_to(state, "AWAKE") - logger.info("在失眠期间到达起床时间，已唤醒。") - - async def _handle_woken_up(self, state: SleepState, now: datetime): - """处理 WOKEN_UP 状态的逻辑""" - # 检查冷却时间是否结束 - if state.state_end_time and now.timestamp() >= state.state_end_time: - if self._is_in_sleep_time_range(now): - await self._transition_to(state, "PREPARING_SLEEP", duration_minutes=self.config.prepare_sleep_duration) - logger.info("被吵醒冷却时间结束，尝试重新入睡。") - else: - await self._transition_to(state, "AWAKE") - logger.info("被吵醒后到达起床时间，已唤醒。") - - async def _handle_unknown(self, state: SleepState, now: datetime): - """处理未知状态""" - logger.warning(f"检测到未知的睡眠状态: {state.current_state}。将重置为 AWAKE。") - await self._transition_to(state, "AWAKE") - - async def handle_external_event(self): - """处理外部事件，例如收到用户消息""" - current_state = await self.state_manager.get_state() - if current_state.current_state in ["SLEEPING", "INSOMNIA"]: - await self._transition_to(current_state, "WOKEN_UP", duration_minutes=self.config.woken_up_cooldown_minutes) - logger.info("在睡眠中被外部事件打断，进入 WOKEN_UP 状态。") - # 在这里可以触发“起床气”情绪 - - async def _transition_to(self, old_state: SleepState, new_state_name: str, duration_minutes: int = 0): - """ - 状态转换的统一处理函数。 - - Args: - old_state: 转换前的状态对象。 - new_state_name: 新状态的名称。 - duration_minutes: 新状态的持续时间（分钟），如果为0则不设结束时间。 - """ - current_timestamp = time.time() - new_end_time = None - if duration_minutes > 0: - new_end_time = current_timestamp + duration_minutes * 60 - - new_state = SleepState( - current_state=new_state_name, - state_end_time=new_end_time, - last_updated=current_timestamp, - metadata=old_state.metadata # 继承 metadata - ) - await self.state_manager.save_state(new_state) - logger.info(f"睡眠状态已从 {old_state.current_state} 转换为 {new_state_name}。") diff --git a/src/plugins/built_in/sleep_system/state_manager.py b/src/plugins/built_in/sleep_system/state_manager.py deleted file mode 100644 index c108cbe59..000000000 --- a/src/plugins/built_in/sleep_system/state_manager.py +++ /dev/null @@ -1,83 +0,0 @@ -import json -import logging -from pathlib import Path -from typing import Optional, Dict, Any -from pydantic import BaseModel, Field -import asyncio - -# 设置日志记录 -logger = logging.getLogger(__name__) - -class SleepState(BaseModel): - """定义睡眠状态的数据模型""" - current_state: str = Field(default="AWAKE", description="当前的睡眠状态") - state_end_time: Optional[float] = Field(default=None, description="当前状态的预计结束时间戳") - last_updated: float = Field(description="状态最后更新的时间戳") - metadata: Dict[str, Any] = Field(default={}, description="用于存储额外状态信息的字典") - -class StateManager: - """ - 负责睡眠状态的持久化管理。 - 将状态以 JSON 格式读/写到本地文件，以降低耦合。 - """ - def __init__(self, state_file_path: Path): - self.state_file_path = state_file_path - self._state: Optional[SleepState] = None - self._lock = asyncio.Lock() - self._load_state() - - def _load_state(self) -> None: - """从文件加载状态，如果文件不存在或为空，则创建默认状态""" - try: - if self.state_file_path.exists() and self.state_file_path.stat().st_size > 0: - with open(self.state_file_path, 'r', encoding='utf-8') as f: - data = json.load(f) - self._state = SleepState(**data) - logger.info(f"睡眠状态已从 {self.state_file_path} 加载。") - else: - self._create_default_state() - except (json.JSONDecodeError, TypeError) as e: - logger.warning(f"无法解析状态文件 {self.state_file_path}: {e}。将创建新的默认状态。") - self._create_default_state() - except Exception as e: - logger.error(f"加载睡眠状态时发生未知错误: {e}") - self._create_default_state() - - def _create_default_state(self) -> None: - """创建一个默认的清醒状态""" - import time - self._state = SleepState(last_updated=time.time()) - logger.info("未找到现有状态文件，已创建默认的睡眠状态 (AWAKE)。") - # 立即保存一次，以确保文件被创建 - asyncio.create_task(self.save_state()) - - async def get_state(self) -> SleepState: - """异步获取当前的状态""" - async with self._lock: - if self._state is None: - self._load_state() - # 此时 _state 必然已被 _load_state 或 _create_default_state 初始化 - assert self._state is not None, "State should be initialized here" - return self._state.copy(deep=True) - - async def save_state(self, new_state: Optional[SleepState] = None) -> None: - """ - 异步保存当前状态到文件。 - 如果提供了 new_state，则先更新内部状态。 - """ - async with self._lock: - if new_state: - self._state = new_state - - if self._state is None: - logger.warning("尝试保存一个空的状态，操作已跳过。") - return - - try: - # 确保目录存在 - self.state_file_path.parent.mkdir(parents=True, exist_ok=True) - with open(self.state_file_path, 'w', encoding='utf-8') as f: - json.dump(self._state.dict(), f, indent=4, ensure_ascii=False) - logger.debug(f"睡眠状态已成功保存到 {self.state_file_path}。") - except Exception as e: - logger.error(f"保存睡眠状态到 {self.state_file_path} 时失败: {e}") diff --git a/src/plugins/built_in/sleep_system/tasks.py b/src/plugins/built_in/sleep_system/tasks.py deleted file mode 100644 index bb7ff82d9..000000000 --- a/src/plugins/built_in/sleep_system/tasks.py +++ /dev/null @@ -1,48 +0,0 @@ -import asyncio -import logging -from typing import Optional -from .sleep_logic import SleepLogic - -logger = logging.getLogger(__name__) - -class SleepCycleTask: - """ - 负责周期性地更新睡眠状态的后台任务。 - """ - def __init__(self, sleep_logic: SleepLogic, interval_seconds: int = 30): - self.sleep_logic = sleep_logic - self.interval_seconds = interval_seconds - self._task: Optional[asyncio.Task] = None - self._is_running = False - - async def _run(self): - """任务的内部循环""" - logger.info("睡眠系统周期性更新任务已启动。") - while self._is_running: - try: - await self.sleep_logic.update_state() - await asyncio.sleep(self.interval_seconds) - except asyncio.CancelledError: - logger.info("睡眠系统任务被取消。") - break - except Exception as e: - logger.error(f"睡眠系统任务在执行期间发生错误: {e}", exc_info=True) - # 发生错误后，等待一段时间再继续，避免快速失败循环 - await asyncio.sleep(self.interval_seconds * 2) - - def start(self): - """启动后台任务""" - if not self._is_running: - self._is_running = True - self._task = asyncio.create_task(self._run()) - else: - logger.warning("尝试启动一个已经在运行的睡眠系统任务。") - - def stop(self): - """停止后台任务""" - if self._is_running and self._task: - self._is_running = False - self._task.cancel() - logger.info("睡眠系统周期性更新任务已请求停止。") - else: - logger.warning("尝试停止一个尚未启动的睡眠系统任务。")