267 lines
10 KiB
Python
267 lines
10 KiB
Python
import asyncio
|
||
import time
|
||
from typing import Dict, List, Optional, Union
|
||
|
||
from src.common.logger import get_module_logger
|
||
from nonebot.adapters.onebot.v11 import Bot
|
||
from ...common.database import db
|
||
from .message_cq import MessageSendCQ
|
||
from .message import MessageSending, MessageThinking, MessageSet
|
||
|
||
from .storage import MessageStorage
|
||
from .config import global_config
|
||
from .utils import truncate_message
|
||
|
||
from src.common.logger import LogConfig, SENDER_STYLE_CONFIG
|
||
|
||
# 定义日志配置
|
||
sender_config = LogConfig(
|
||
# 使用消息发送专用样式
|
||
console_format=SENDER_STYLE_CONFIG["console_format"],
|
||
file_format=SENDER_STYLE_CONFIG["file_format"],
|
||
)
|
||
|
||
logger = get_module_logger("msg_sender", config=sender_config)
|
||
|
||
|
||
class Message_Sender:
|
||
"""发送器"""
|
||
|
||
def __init__(self):
|
||
self.message_interval = (0.5, 1) # 消息间隔时间范围(秒)
|
||
self.last_send_time = 0
|
||
self._current_bot = None
|
||
|
||
def set_bot(self, bot: Bot):
|
||
"""设置当前bot实例"""
|
||
self._current_bot = bot
|
||
|
||
def get_recalled_messages(self, stream_id: str) -> list:
|
||
"""获取所有撤回的消息"""
|
||
recalled_messages = []
|
||
|
||
recalled_messages = list(db.recalled_messages.find({"stream_id": stream_id}, {"message_id": 1}))
|
||
# 按thinking_start_time排序，时间早的在前面
|
||
return recalled_messages
|
||
|
||
async def send_message(
|
||
self,
|
||
message: MessageSending,
|
||
) -> None:
|
||
"""发送消息"""
|
||
|
||
if isinstance(message, MessageSending):
|
||
recalled_messages = self.get_recalled_messages(message.chat_stream.stream_id)
|
||
is_recalled = False
|
||
for recalled_message in recalled_messages:
|
||
if message.reply_to_message_id == recalled_message["message_id"]:
|
||
is_recalled = True
|
||
logger.warning(f"消息“{message.processed_plain_text}”已被撤回，不发送")
|
||
break
|
||
if not is_recalled:
|
||
message_json = message.to_dict()
|
||
message_send = MessageSendCQ(data=message_json)
|
||
message_preview = truncate_message(message.processed_plain_text)
|
||
if message_send.message_info.group_info and message_send.message_info.group_info.group_id:
|
||
try:
|
||
await self._current_bot.send_group_msg(
|
||
group_id=message.message_info.group_info.group_id,
|
||
message=message_send.raw_message,
|
||
auto_escape=False,
|
||
)
|
||
logger.success(f"发送消息“{message_preview}”成功")
|
||
except Exception as e:
|
||
logger.error(f"[调试] 发生错误 {e}")
|
||
logger.error(f"[调试] 发送消息“{message_preview}”失败")
|
||
else:
|
||
try:
|
||
logger.debug(message.message_info.user_info)
|
||
await self._current_bot.send_private_msg(
|
||
user_id=message.sender_info.user_id,
|
||
message=message_send.raw_message,
|
||
auto_escape=False,
|
||
)
|
||
logger.success(f"发送消息“{message_preview}”成功")
|
||
except Exception as e:
|
||
logger.error(f"[调试] 发生错误 {e}")
|
||
logger.error(f"[调试] 发送消息“{message_preview}”失败")
|
||
|
||
|
||
class MessageContainer:
|
||
"""单个聊天流的发送/思考消息容器"""
|
||
|
||
def __init__(self, chat_id: str, max_size: int = 100):
|
||
self.chat_id = chat_id
|
||
self.max_size = max_size
|
||
self.messages = []
|
||
self.last_send_time = 0
|
||
self.thinking_timeout = 20 # 思考超时时间（秒）
|
||
|
||
def get_timeout_messages(self) -> List[MessageSending]:
|
||
"""获取所有超时的Message_Sending对象（思考时间超过30秒），按thinking_start_time排序"""
|
||
current_time = time.time()
|
||
timeout_messages = []
|
||
|
||
for msg in self.messages:
|
||
if isinstance(msg, MessageSending):
|
||
if current_time - msg.thinking_start_time > self.thinking_timeout:
|
||
timeout_messages.append(msg)
|
||
|
||
# 按thinking_start_time排序，时间早的在前面
|
||
timeout_messages.sort(key=lambda x: x.thinking_start_time)
|
||
|
||
return timeout_messages
|
||
|
||
def get_earliest_message(self) -> Optional[Union[MessageThinking, MessageSending]]:
|
||
"""获取thinking_start_time最早的消息对象"""
|
||
if not self.messages:
|
||
return None
|
||
earliest_time = float("inf")
|
||
earliest_message = None
|
||
for msg in self.messages:
|
||
msg_time = msg.thinking_start_time
|
||
if msg_time < earliest_time:
|
||
earliest_time = msg_time
|
||
earliest_message = msg
|
||
return earliest_message
|
||
|
||
def add_message(self, message: Union[MessageThinking, MessageSending]) -> None:
|
||
"""添加消息到队列"""
|
||
if isinstance(message, MessageSet):
|
||
for single_message in message.messages:
|
||
self.messages.append(single_message)
|
||
else:
|
||
self.messages.append(message)
|
||
|
||
def remove_message(self, message: Union[MessageThinking, MessageSending]) -> bool:
|
||
"""移除消息，如果消息存在则返回True，否则返回False"""
|
||
try:
|
||
if message in self.messages:
|
||
self.messages.remove(message)
|
||
return True
|
||
return False
|
||
except Exception:
|
||
logger.exception("移除消息时发生错误")
|
||
return False
|
||
|
||
def has_messages(self) -> bool:
|
||
"""检查是否有待发送的消息"""
|
||
return bool(self.messages)
|
||
|
||
def get_all_messages(self) -> List[Union[MessageSending, MessageThinking]]:
|
||
"""获取所有消息"""
|
||
return list(self.messages)
|
||
|
||
|
||
class MessageManager:
|
||
"""管理所有聊天流的消息容器"""
|
||
|
||
def __init__(self):
|
||
self.containers: Dict[str, MessageContainer] = {} # chat_id -> MessageContainer
|
||
self.storage = MessageStorage()
|
||
self._running = True
|
||
|
||
def get_container(self, chat_id: str) -> MessageContainer:
|
||
"""获取或创建聊天流的消息容器"""
|
||
if chat_id not in self.containers:
|
||
self.containers[chat_id] = MessageContainer(chat_id)
|
||
return self.containers[chat_id]
|
||
|
||
def add_message(self, message: Union[MessageThinking, MessageSending, MessageSet]) -> None:
|
||
chat_stream = message.chat_stream
|
||
if not chat_stream:
|
||
raise ValueError("无法找到对应的聊天流")
|
||
container = self.get_container(chat_stream.stream_id)
|
||
container.add_message(message)
|
||
|
||
async def process_chat_messages(self, chat_id: str):
|
||
"""处理聊天流消息"""
|
||
container = self.get_container(chat_id)
|
||
if container.has_messages():
|
||
# print(f"处理有message的容器chat_id: {chat_id}")
|
||
message_earliest = container.get_earliest_message()
|
||
|
||
if isinstance(message_earliest, MessageThinking):
|
||
message_earliest.update_thinking_time()
|
||
thinking_time = message_earliest.thinking_time
|
||
# print(thinking_time)
|
||
print(
|
||
f"消息正在思考中，已思考{int(thinking_time)}秒\r",
|
||
end="",
|
||
flush=True,
|
||
)
|
||
|
||
# 检查是否超时
|
||
if thinking_time > global_config.thinking_timeout:
|
||
logger.warning(f"消息思考超时({thinking_time}秒)，移除该消息")
|
||
container.remove_message(message_earliest)
|
||
|
||
else:
|
||
# print(message_earliest.is_head)
|
||
# print(message_earliest.update_thinking_time())
|
||
# print(message_earliest.is_private_message())
|
||
# thinking_time = message_earliest.update_thinking_time()
|
||
# print(thinking_time)
|
||
if (
|
||
message_earliest.is_head
|
||
and message_earliest.update_thinking_time() > 15
|
||
and not message_earliest.is_private_message() # 避免在私聊时插入reply
|
||
):
|
||
logger.debug(f"设置回复消息{message_earliest.processed_plain_text}")
|
||
message_earliest.set_reply()
|
||
|
||
await message_earliest.process()
|
||
|
||
await message_sender.send_message(message_earliest)
|
||
|
||
await self.storage.store_message(message_earliest, message_earliest.chat_stream, None)
|
||
|
||
container.remove_message(message_earliest)
|
||
|
||
message_timeout = container.get_timeout_messages()
|
||
if message_timeout:
|
||
logger.debug(f"发现{len(message_timeout)}条超时消息")
|
||
for msg in message_timeout:
|
||
if msg == message_earliest:
|
||
continue
|
||
|
||
try:
|
||
# print(msg.is_head)
|
||
# print(msg.update_thinking_time())
|
||
# print(msg.is_private_message())
|
||
if (
|
||
msg.is_head
|
||
and msg.update_thinking_time() > 15
|
||
and not msg.is_private_message() # 避免在私聊时插入reply
|
||
):
|
||
logger.debug(f"设置回复消息{msg.processed_plain_text}")
|
||
msg.set_reply()
|
||
|
||
await msg.process()
|
||
|
||
await message_sender.send_message(msg)
|
||
|
||
await self.storage.store_message(msg, msg.chat_stream, None)
|
||
|
||
if not container.remove_message(msg):
|
||
logger.warning("尝试删除不存在的消息")
|
||
except Exception:
|
||
logger.exception("处理超时消息时发生错误")
|
||
continue
|
||
|
||
async def start_processor(self):
|
||
"""启动消息处理器"""
|
||
while self._running:
|
||
await asyncio.sleep(1)
|
||
tasks = []
|
||
for chat_id in self.containers.keys():
|
||
tasks.append(self.process_chat_messages(chat_id))
|
||
|
||
await asyncio.gather(*tasks)
|
||
|
||
|
||
# 创建全局消息管理器实例
|
||
message_manager = MessageManager()
|
||
# 创建全局发送器实例
|
||
message_sender = Message_Sender()
|