K2CrO4/NeoBot
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Dev (#28)

Browse Source 
* 滚木

* feat: 重构核心架构，增强类型安全与插件管理

本次提交对核心模块进行了深度重构，引入 Pydantic 增强配置管理的类型安全性，并全面优化了插件管理系统。

主要变更详情：

1. 核心架构与配置
   - 重构配置加载模块：引入 Pydantic 模型 (`core/config_models.py`)，提供严格的配置项类型检查、验证及默认值管理。
   - 统一模块结构：规范化模块导入路径，移除冗余的 `__init__.py` 文件，提升项目结构的清晰度。
   - 性能优化：集成 Redis 缓存支持 (`RedisManager`)，有效降低高频 API 调用开销，提升响应速度。

2. 插件系统升级
   - 实现热重载机制：新增插件文件变更监听功能，支持开发过程中自动重载插件，提升开发效率。
   - 优化生命周期管理：改进插件加载与卸载逻辑，支持精确卸载指定插件及其关联的命令、事件处理器和定时任务。

3. 功能特性增强
   - 新增媒体 API：引入 `MediaAPI` 模块，封装图片、语音等富媒体资源的获取与处理接口。
   - 完善权限体系：重构权限管理系统，实现管理员与操作员的分级控制，支持更细粒度的命令权限校验。

4. 代码质量与稳定性
   - 全面类型修复：解决 `mypy` 静态类型检查发现的大量类型错误（包括 `CommandManager`、`EventFactory` 及 `Bot` API 签名不匹配问题）。
   - 增强错误处理：优化消息处理管道的异常捕获机制，完善关键路径的日志记录，提升系统运行稳定性。

* feat: 添加测试用例并优化代码结构

refactor(permission_manager): 调整初始化顺序和逻辑
fix(admin_manager): 修复初始化逻辑和目录创建问题
feat(ws): 优化Bot实例初始化条件
feat(message): 增强MessageSegment功能并添加测试
feat(events): 支持字符串格式的消息解析
test: 添加核心功能测试用例
refactor(plugin_manager): 改进插件路径处理
style: 清理无用导入和代码
chore: 更新依赖项
This commit is contained in:
镀铬酸钾
2026-01-09 00:20:56 +08:00
committed by GitHub
parent 6d7dfc179d
commit fa81229f6f
42 changed files with 1461 additions and 697 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
core/managers/__init__.py
View File

@@ -0,0 +1,40 @@
"""
管理器包
这个包集中了机器人核心的单例管理器。
通过从这里导入，可以确保在整个应用中访问到的都是同一个实例。
"""
from ..config_loader import global_config
from .admin_manager import AdminManager
from .command_manager import CommandManager
from .permission_manager import PermissionManager
from .plugin_manager import PluginManager
from .redis_manager import RedisManager
# --- 实例化所有单例管理器 ---
# 管理员管理器
admin_manager = AdminManager()
# 权限管理器
permission_manager = PermissionManager()
# 命令与事件管理器 (别名 matcher)
command_manager = CommandManager(prefixes=tuple(global_config.bot.command))
matcher = command_manager
# 插件管理器
plugin_manager = PluginManager(command_manager)
plugin_manager.load_all_plugins()
# Redis 管理器
redis_manager = RedisManager()
__all__ = [
"admin_manager",
"permission_manager",
"command_manager",
"matcher",
"plugin_manager",
"redis_manager",
]

8
core/managers/admin_manager.py
View File

@@ -26,8 +26,7 @@ class AdminManager(Singleton):
"""
初始化 AdminManager
"""
super().__init__()
if not self._initialized:
if hasattr(self, '_initialized') and self._initialized:
return
# 管理员数据文件路径
@@ -39,7 +38,12 @@ class AdminManager(Singleton):
)
self._admins: Set[int] = set()
# 确保数据目录存在
os.makedirs(os.path.dirname(self.data_file), exist_ok=True)
logger.info("管理员管理器初始化完成")
super().__init__()
async def initialize(self):
"""

52
core/managers/command_manager.py
View File

@@ -12,7 +12,16 @@ from ..handlers.event_handler import MessageHandler, NoticeHandler, RequestHandl
# 从配置中获取命令前缀
command_prefixes = global_config.bot.get("command", ("/",))
_config_prefixes = global_config.bot.command
# 确保前缀配置是元组格式
_final_prefixes: Tuple[str, ...]
if isinstance(_config_prefixes, list):
_final_prefixes = tuple(_config_prefixes)
elif isinstance(_config_prefixes, str):
_final_prefixes = (_config_prefixes,)
else:
_final_prefixes = tuple(_config_prefixes)
class CommandManager:
@@ -59,6 +68,35 @@ class CommandManager:
"usage": "/help",
}
def clear_all_handlers(self):
"""
清空所有已注册的事件处理器。
注意：这也会移除内置的 /help 命令，因此需要重新注册。
"""
self.message_handler.clear()
self.notice_handler.clear()
self.request_handler.clear()
self.plugins.clear()
# 清空后，需要重新注册内置命令
self._register_internal_commands()
def unload_plugin(self, plugin_name: str):
"""
卸载指定插件的所有处理器和命令。
Args:
plugin_name (str): 插件的模块名 (例如 'plugins.bili_parser')
"""
self.message_handler.unregister_by_plugin_name(plugin_name)
self.notice_handler.unregister_by_plugin_name(plugin_name)
self.request_handler.unregister_by_plugin_name(plugin_name)
# 移除插件元信息
plugins_to_remove = [name for name in self.plugins if name.startswith(plugin_name)]
for name in plugins_to_remove:
del self.plugins[name]
# --- 装饰器代理 ---
def on_message(self) -> Callable:
@@ -102,7 +140,7 @@ class CommandManager:
根据事件的 `post_type` 将其分发给对应的处理器。
"""
if event.post_type == 'message' and global_config.bot.get('ignore_self_message', False):
if event.post_type == 'message' and global_config.bot.ignore_self_message:
if hasattr(event, 'user_id') and hasattr(event, 'self_id') and event.user_id == event.self_id:
return
@@ -130,14 +168,6 @@ class CommandManager:
await bot.send(event, help_text.strip())
# --- 全局单例 ---
# 确保前缀配置是元组格式
if isinstance(command_prefixes, list):
command_prefixes = tuple(command_prefixes)
elif isinstance(command_prefixes, str):
command_prefixes = (command_prefixes,)
# 实例化全局唯一的命令管理器
matcher = CommandManager(prefixes=command_prefixes)
matcher = CommandManager(prefixes=_final_prefixes)

95
core/managers/permission_manager.py
View File

@@ -13,64 +13,17 @@
"""
import json
import os
from functools import total_ordering
from typing import Dict
from typing import Dict, Optional
from ..utils.logger import logger
from ..utils.singleton import Singleton
from .admin_manager import admin_manager
from ..permission import Permission
@total_ordering
class Permission:
"""
权限封装类
封装了权限的名称和等级，并提供了比较方法。
使用 @total_ordering 装饰器可以自动生成所有的比较运算符。
"""
def __init__(self, name: str, level: int):
"""
初始化权限对象
Args:
name (str): 权限名称 (e.g., "admin", "op")
level (int): 权限等级，数字越大权限越高
"""
self.name = name
self.level = level
def __eq__(self, other):
"""
判断权限是否相等
"""
if not isinstance(other, Permission):
return NotImplemented
return self.level == other.level
def __lt__(self, other):
"""
判断权限是否小于另一个权限
"""
if not isinstance(other, Permission):
return NotImplemented
return self.level < other.level
def __str__(self) -> str:
"""
返回权限的字符串表示（即权限名称）
"""
return self.name
# 定义全局权限常量
ADMIN = Permission("admin", 3)
OP = Permission("op", 2)
USER = Permission("user", 1)
# 用于从字符串名称查找权限对象的字典
_PERMISSIONS: Dict[str, Permission] = {
p.name: p for p in [ADMIN, OP, USER]
p.value: p for p in Permission
}
@@ -88,8 +41,7 @@ class PermissionManager(Singleton):
如果已经初始化过，则直接返回。
"""
super().__init__()
if not self._initialized:
if hasattr(self, '_initialized') and self._initialized:
return
# 权限数据文件路径
@@ -111,6 +63,7 @@ class PermissionManager(Singleton):
self.load()
logger.info("权限管理器初始化完成")
super().__init__()
def load(self) -> None:
"""
@@ -164,12 +117,12 @@ class PermissionManager(Singleton):
"""
# 首先，通过 AdminManager 检查是否为管理员
if await admin_manager.is_admin(user_id):
return ADMIN
return Permission.ADMIN
# 如果不是管理员，则从 permissions.json 中查找
user_id_str = str(user_id)
level_name = self._data["users"].get(user_id_str, USER.name)
return _PERMISSIONS.get(level_name, USER)
level_name = self._data["users"].get(user_id_str, Permission.USER.value)
return _PERMISSIONS.get(level_name, Permission.USER)
def set_user_permission(self, user_id: int, permission: Permission) -> None:
"""
@@ -182,13 +135,13 @@ class PermissionManager(Singleton):
Raises:
ValueError: 如果权限对象无效
"""
if not isinstance(permission, Permission) or permission.name not in _PERMISSIONS:
if not isinstance(permission, Permission):
raise ValueError(f"无效的权限对象: {permission}")
user_id_str = str(user_id)
self._data["users"][user_id_str] = permission.name
self._data["users"][user_id_str] = permission.value
self.save()
logger.info(f"设置用户 {user_id} 的权限级别为 {permission.name}")
logger.info(f"设置用户 {user_id} 的权限级别为 {permission.value}")
def remove_user(self, user_id: int) -> None:
"""
@@ -214,17 +167,17 @@ class PermissionManager(Singleton):
Returns:
bool: 如果用户权限 >= 所需权限，返回 True，否则返回 False
"""
# 如果传入的是字符串，先转换为 Permission 对象
if isinstance(required_permission, str):
required_permission = _PERMISSIONS.get(required_permission.lower())
if not required_permission:
# 如果是无效的权限字符串，默认拒绝
logger.warning(f"检测到无效的权限检查字符串: {required_permission}")
return False
user_permission = await self.get_user_permission(user_id)
return user_permission >= required_permission
def get_all_user_permissions(self) -> Dict[str, str]:
"""
获取所有已配置的用户权限
:return: 一个包含所有用户权限的字典
"""
return self._data["users"].copy()
def get_all_users(self) -> Dict[str, str]:
"""
获取所有设置了权限的用户及其级别名称
@@ -243,22 +196,22 @@ class PermissionManager(Singleton):
logger.info("已清空所有权限设置")
# 全局权限管理器实例
permission_manager = PermissionManager()
def require_admin(func):
"""
一个装饰器，用于限制命令只能由管理员执行。
"""
from functools import wraps
from models.events.message import MessageEvent
from core.managers import permission_manager
@wraps(func)
async def wrapper(event: MessageEvent, *args, **kwargs):
user_id = event.user_id
if await permission_manager.check_permission(user_id, ADMIN):
if await permission_manager.check_permission(user_id, Permission.ADMIN):
return await func(event, *args, **kwargs)
else:
await event.reply("抱歉，您没有权限执行此命令。")
# 假设 event 对象有 reply 方法
if hasattr(event, "reply"):
await event.reply("抱歉，您没有权限执行此命令。")
return None
return wrapper

179
core/managers/plugin_manager.py
View File

@@ -1,126 +1,97 @@
"""
插件管理器模块
负责扫描、加载和管理 `base_plugins` 目录下的所有插件。
负责扫描、加载和管理 `plugins` 目录下的所有插件。
"""
import importlib
import json
import os
import pkgutil
import sys
from typing import Set
from .command_manager import matcher
from ..utils.exceptions import SyncHandlerError
from ..utils.logger import logger
from ..utils.executor import run_in_thread_pool
def load_all_plugins():
class PluginManager:
"""
扫描并加载 `plugins` 目录下的所有插件。
该函数会遍历 `plugins` 目录下的所有模块：
1. 如果模块已加载，则执行 reload 操作（用于热重载）。
2. 如果模块未加载，则执行 import 操作。
加载过程中会提取插件元数据 `__plugin_meta__` 并注册到 CommandManager。
插件管理器类
"""
plugin_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)), "..", "plugins"
)
package_name = "plugins"
def __init__(self, command_manager):
"""
初始化插件管理器
logger.info(f"正在从 {package_name} 加载插件...")
:param command_manager: CommandManager的实例
"""
self.command_manager = command_manager
self.loaded_plugins: Set[str] = set()
for loader, module_name, is_pkg in pkgutil.iter_modules([plugin_dir]):
full_module_name = f"{package_name}.{module_name}"
def load_all_plugins(self):
"""
扫描并加载 `plugins` 目录下的所有插件。
"""
# 使用 pathlib 获取更可靠的路径
# 当前文件: core/managers/plugin_manager.py
# 目标: plugins/
current_dir = os.path.dirname(os.path.abspath(__file__))
# 回退两级到项目根目录 (core/managers -> core -> root)
root_dir = os.path.dirname(os.path.dirname(current_dir))
plugin_dir = os.path.join(root_dir, "plugins")
package_name = "plugins"
if not os.path.exists(plugin_dir):
logger.error(f"插件目录不存在: {plugin_dir}")
return
logger.info(f"正在从 {package_name} 加载插件 (路径: {plugin_dir})...")
for _, module_name, is_pkg in pkgutil.iter_modules([plugin_dir]):
full_module_name = f"{package_name}.{module_name}"
try:
if full_module_name in self.loaded_plugins:
self.command_manager.unload_plugin(full_module_name)
module = importlib.reload(sys.modules[full_module_name])
action = "重载"
else:
module = importlib.import_module(full_module_name)
action = "加载"
if hasattr(module, "__plugin_meta__"):
meta = getattr(module, "__plugin_meta__")
self.command_manager.plugins[full_module_name] = meta
self.loaded_plugins.add(full_module_name)
type_str = "包" if is_pkg else "文件"
logger.success(f" [{type_str}] 成功{action}: {module_name}")
except SyncHandlerError as e:
logger.error(f" 插件 {module_name} 加载失败: {e} (跳过此插件)")
except Exception as e:
logger.exception(
f" {action if 'action' in locals() else '加载'}插件 {module_name} 失败: {e}"
)
def reload_plugin(self, full_module_name: str):
"""
精确重载单个插件。
"""
if full_module_name not in self.loaded_plugins:
logger.warning(f"尝试重载一个未被加载的插件: {full_module_name}，将按首次加载处理。")
if full_module_name not in sys.modules:
logger.error(f"重载失败: 模块 {full_module_name} 未在 sys.modules 中找到。")
return
try:
if full_module_name in sys.modules:
module = importlib.reload(sys.modules[full_module_name])
action = "重载"
else:
module = importlib.import_module(full_module_name)
action = "加载"
# 提取插件元数据
self.command_manager.unload_plugin(full_module_name)
module = importlib.reload(sys.modules[full_module_name])
if hasattr(module, "__plugin_meta__"):
meta = getattr(module, "__plugin_meta__")
matcher.plugins[full_module_name] = meta
type_str = "包" if is_pkg else "文件"
logger.success(f" [{type_str}] 成功{action}: {module_name}")
except SyncHandlerError as e:
logger.error(f" 插件 {module_name} 加载失败: {e} (跳过此插件)")
self.command_manager.plugins[full_module_name] = meta
logger.success(f"插件 {full_module_name} 已成功重载。")
except Exception as e:
print(
f" {action if 'action' in locals() else '加载'}插件 {module_name} 失败: {e}"
)
class PluginDataManager:
"""
用于管理插件产生的数据文件的类
"""
def __init__(self, plugin_name: str):
"""
初始化插件数据管理器
:param plugin_name: 插件名称
"""
self.plugin_name = plugin_name
self.data_file = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"..",
"plugins",
"data",
self.plugin_name + ".json",
)
self.data = {}
async def load(self):
"""读取配置文件"""
if not os.path.exists(self.data_file):
await self.set(self.plugin_name, [])
try:
with open(self.data_file, "r", encoding="utf-8") as f:
self.data = await run_in_thread_pool(json.load, f)
except json.JSONDecodeError:
self.data = {}
async def save(self):
"""保存配置到文件"""
with open(self.data_file, "w", encoding="utf-8") as f:
await run_in_thread_pool(json.dump, self.data, f, indent=2, ensure_ascii=False)
def get(self, key, default=None):
"""获取配置项"""
return self.data.get(key, default)
async def set(self, key, value):
"""设置配置项"""
self.data[key] = value
await self.save()
async def add(self, key, value):
"""添加配置项"""
if key not in self.data:
self.data[key] = []
self.data[key].append(value)
await self.save()
async def remove(self, key):
"""删除配置项"""
if key in self.data:
del self.data[key]
await self.save()
async def clear(self):
"""清空所有配置"""
self.data.clear()
await self.save()
def get_all(self):
return self.data.copy()
logger.exception(f"重载插件 {full_module_name} 时发生错误: {e}")

21
core/managers/redis_manager.py
View File

@@ -20,10 +20,11 @@ class RedisManager:
"""
if self._redis is None:
try:
host = config.redis['host']
port = config.redis['port']
db = config.redis['db']
password = config.redis.get('password')
redis_config = config.redis
host = redis_config.host
port = redis_config.port
db = redis_config.db
password = redis_config.password
logger.info(f"正在尝试连接 Redis: {host}:{port}, DB: {db}")
@@ -54,5 +55,17 @@ class RedisManager:
raise ConnectionError("Redis 未初始化或连接失败，请先调用 initialize()")
return self._redis
async def get(self, name):
"""
获取指定键的值
"""
return await self.redis.get(name)
async def set(self, name, value, ex=None):
"""
设置指定键的值
"""
return await self.redis.set(name, value, ex=ex)
# 全局 Redis 管理器实例
redis_manager = RedisManager()