ErisPulse 1.1.15__py3-none-any.whl → 1.2.0__py3-none-any.whl

ErisPulse/__init__.py

@@ -36,10 +36,13 @@ sdk.logger.info("SDK已初始化")
 
 """
 
-import types
-sdk = types.SimpleNamespace()
 import os
 import sys
+
+# 依赖类型
+import types
+
+# BaseModules: SDK核心模块
 from . import util
 from .raiserr import raiserr
 from .logger import logger
@@ -50,177 +53,254 @@ from .adapter import adapter, BaseAdapter, SendDSL
 # 这里不能删，确保windows下的shell能正确显示颜色
 os.system('')
 
-setattr(sdk, "env", env)
-setattr(sdk, "mods", mods)
-setattr(sdk, "util", util)
-setattr(sdk, "raiserr", raiserr)
-setattr(sdk, "logger", logger)
-setattr(sdk, "adapter", adapter)
-setattr(sdk, "SendDSL", SendDSL)
-setattr(sdk, "BaseAdapter", BaseAdapter)
-
-# 注册 ErrorHook 并预注册常用错误类型
-raiserr.register("CaughtExternalError"      , doc="捕获的非SDK抛出的异常")
-raiserr.register("InitError"               , doc="SDK初始化错误")
-raiserr.register("MissingDependencyError"   , doc="缺少依赖错误")
-raiserr.register("InvalidDependencyError"   , doc="依赖无效错误")
-raiserr.register("CycleDependencyError"     , doc="依赖循环错误")
-raiserr.register("ModuleLoadError"          , doc="模块加载错误")
-
-def init() -> None:
+sdk = types.SimpleNamespace()
+
+BaseModules = {
+    "util"          : util,
+    "logger"        : logger,
+    "env"           : env,
+    "mods"          : mods,
+    "adapter"       : adapter,
+    "SendDSL"       : SendDSL,      # 链式发送基类 - 兼容原 sdk.SendDSL | 待弃用, 需要在 Adapter继承类中手动创建嵌套类并集成 super().SendDSL()
+    "AdapterFather" : BaseAdapter,
+    "BaseAdapter"   : BaseAdapter
+}
+
+BaseErrors = {
+    "ExternalError"             : "外部捕获异常",
+    "CaughtExternalError"       : "捕获的非SDK抛出的异常", 
+    "InitError"                 : "SDK初始化错误",
+    "MissingDependencyError"    : "缺少依赖错误",
+    "InvalidDependencyError"    : "依赖无效错误",
+    "CycleDependencyError"      : "依赖循环错误",
+    "ModuleLoadError"           : "模块加载错误"
+}
+
+for module, moduleObj in BaseModules.items():
+    try:
+        setattr(sdk, module, moduleObj)
+    except Exception as e:
+        raise e
+
+for error, doc in BaseErrors.items():
     try:
-        logger.info("[Init] SDK 正在初始化...")
-        if env.create_env_file_if_not_exists():
+        raiserr.register(error, doc=doc)
+    except Exception as e:
+        raise e
+def init_progress():
+    from pathlib import Path
+    env_file = Path("env.py")
+    main_file = Path("main.py")
+
+    if not env_file.exists():
+        content = '''# env.py
+# ErisPulse 环境配置文件
+# 本文件由 SDK 自动创建，请勿随意删除
+# 配置项可通过 sdk.env.get(key, default) 获取，或使用 sdk.env.set(key, value) 设置
+# 你也可以像写普通变量一样直接定义配置项，例如：
+#
+#     MY_CONFIG = "value"
+#     MY_CONFIG_2 = {"key": "value"}
+#     MY_CONFIG_3 = [1, 2, 3]
+#
+#     sdk.env.set("MY_CONFIG", "value")
+#     sdk.env.set("MY_CONFIG_2", {"key": "value"})
+#     sdk.env.set("MY_CONFIG_3", [1, 2, 3])
+#
+# 这些变量会自动被加载到 SDK 的配置系统中，可通过 sdk.env.MY_CONFIG 或 sdk.env.get("MY_CONFIG") 访问。
+
+from ErisPulse import sdk
+'''
+    if not main_file.exists():
+        content += '''# main.py
+# ErisPulse 主程序文件
+# 本文件由 SDK 自动创建，您可随意修改
+
+from ErisPulse import sdk
+
+async def main():
+    try:
+        sdk.init()
+        await sdk.adapter.startup()
+
+    except Exception as e:
+        sdk.logger.error(e)
+    except KeyboardInterrupt:
+        sdk.logger.info("正在停止程序")
+    finally:
+        await sdk.shutdown()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+'''
+        try:
+            with open(env_file, "w", encoding="utf-8") as f:
+                f.write(content)
+            return True
+        except Exception as e:
+            from . import sdk
+            sdk.logger.error(f"无法初始化项目环境: {e}")
+            return False
+    return False
+
+def _prepare_environment() -> bool:
+    # 检查环境
+    logger.info("[Init] 准备初始化环境...")
+    try:
+        if init_progress():
             logger.info("[Init] 项目首次初始化，建议先配置环境变量")
             if input("是否立即退出？(y/n): ").strip().lower() == "y":
-                sys.exit(0)
+                return False
         env.load_env_file()
-
-        sdkModulePath = os.path.join(os.path.dirname(__file__), "modules")
-
-        if not os.path.exists(sdkModulePath):
-            os.makedirs(sdkModulePath)
-
-        sys.path.append(sdkModulePath)
-
-        TempModules = [
-            x for x in os.listdir(sdkModulePath)
-            if os.path.isdir(os.path.join(sdkModulePath, x))
-        ]
-
-        sdkInstalledModuleNames: list[str] = []
-        disabledModules: list[str] = []
-
-        # ==== 扫描模块并收集基本信息 ====
-        module_objs = {}  # {module_name: moduleObj}
-        for module_name in TempModules:
-            try:
-                moduleObj = __import__(module_name)
-                if not hasattr(moduleObj, "moduleInfo") or not isinstance(moduleObj.moduleInfo, dict):
-                    logger.warning(f"模块 {module_name} 缺少有效的 'moduleInfo' 字典.")
-                    continue
-                if "name" not in moduleObj.moduleInfo.get("meta", {}):
-                    logger.warning(f"模块 {module_name} 的 'moduleInfo' 字典 缺少必要 'name' 键.")
-                    continue
-                if not hasattr(moduleObj, "Main"):
-                    logger.warning(f"模块 {module_name} 缺少 'Main' 类.")
-                    continue
-
-                meta_name = moduleObj.moduleInfo["meta"]["name"]
-                module_info = mods.get_module(meta_name)
-                if module_info is None:
-                    module_info = {
-                        "status": True,
-                        "info": moduleObj.moduleInfo
-                    }
-                    mods.set_module(meta_name, module_info)
-                    logger.info(f"模块 {meta_name} 信息已初始化并存储到数据库")
-
-                if not module_info.get('status', True):
-                    disabledModules.append(module_name)
-                    logger.warning(f"模块 {meta_name} 已禁用，跳过加载")
-                    continue
-
-                required_deps = moduleObj.moduleInfo.get("dependencies", {}).get("requires", [])
-                missing_required_deps = [dep for dep in required_deps if dep not in TempModules]
-                if missing_required_deps:
-                    logger.error(f"模块 {module_name} 缺少必需依赖: {missing_required_deps}")
-                    raiserr.MissingDependencyError(f"模块 {module_name} 缺少必需依赖: {missing_required_deps}")
-
-                optional_deps = moduleObj.moduleInfo.get("dependencies", {}).get("optional", [])
-                available_optional_deps = []
-                for dep in optional_deps:
-                    if isinstance(dep, list):
-                        available_deps = [d for d in dep if d in TempModules]
-                        if available_deps:
-                            available_optional_deps.extend(available_deps)
-                    elif dep in TempModules:
-                        available_optional_deps.append(dep)
-
-                if optional_deps and not available_optional_deps:
-                    logger.warning(f"模块 {module_name} 缺少所有可选依赖: {optional_deps}")
-
-                module_objs[module_name] = moduleObj
-                sdkInstalledModuleNames.append(module_name)
-
-            except Exception as e:
-                logger.warning(f"模块 {module_name} 加载失败: {e}")
+        return True
+    except Exception as e:
+        logger.error(f"环境准备失败: {e}")
+        return False
+def _scan_modules(module_path: str) -> tuple[dict, list, list]:
+    # 扫描并验证模块
+    module_objs = {}
+    enabled_modules = []
+    disabled_modules = []
+    
+    if not os.path.exists(module_path):
+        os.makedirs(module_path)
+    sys.path.append(module_path)
+
+    for module_name in os.listdir(module_path):
+        if not os.path.isdir(os.path.join(module_path, module_name)):
+            continue
+            
+        try:
+            moduleObj = __import__(module_name)
+            if not _validate_module(moduleObj, module_name):
                 continue
-
-        # ==== 构建依赖图并进行拓扑排序 ====
-        sdkModuleDependencies = {}
-        for module_name in sdkInstalledModuleNames:
-            moduleObj = module_objs[module_name]
+                
             meta_name = moduleObj.moduleInfo["meta"]["name"]
-
-            req_deps = moduleObj.moduleInfo.get("dependencies", {}).get("requires", [])
-            opt_deps = moduleObj.moduleInfo.get("dependencies", {}).get("optional", [])
-
-            available_optional_deps = [dep for dep in opt_deps if dep in sdkInstalledModuleNames]
-            deps = req_deps + available_optional_deps
-
-            for dep in deps:
-                if dep in disabledModules:
-                    logger.warning(f"模块 {meta_name} 的依赖模块 {dep} 已禁用，跳过加载")
-                    continue
-
-            if not all(dep in sdkInstalledModuleNames for dep in deps):
-                raiserr.InvalidDependencyError(f"模块 {meta_name} 的依赖无效: {deps}")
-            sdkModuleDependencies[module_name] = deps
-
-        sdkInstalledModuleNames: list[str] = sdk.util.topological_sort(
-            sdkInstalledModuleNames, sdkModuleDependencies, raiserr.CycleDependencyError
-        )
-        # 存储模块依赖关系到env
-        env.set('module_dependencies', {
-            'modules': sdkInstalledModuleNames,
-            'dependencies': sdkModuleDependencies
-        })
-
-        # ==== 注册适配器 ====
-        logger.debug("[Init] 开始注册适配器...")
-        for module_name in sdkInstalledModuleNames:
-            moduleObj = module_objs[module_name]
-            meta_name = moduleObj.moduleInfo["meta"]["name"]
-
-            try:
-                if hasattr(moduleObj, "adapterInfo") and isinstance(moduleObj.adapterInfo, dict):
-                    for platform_name, adapter_class in moduleObj.adapterInfo.items():
-                        sdk.adapter.register(platform_name, adapter_class)
-                        logger.info(f"模块 {meta_name} 注册了适配器: {platform_name}")
-            except Exception as e:
-                logger.error(f"模块 {meta_name} 注册适配器失败: {e}")
-
-        # ==== 存储模块信息到数据库 ====
-        all_modules_info = {}
-        for module_name in sdkInstalledModuleNames:
-            moduleObj = module_objs[module_name]
-            moduleInfo: dict = moduleObj.moduleInfo
-
-            meta_name = moduleInfo.get("meta", {}).get("name", None)
-            module_info = mods.get_module(meta_name)
-            mods.set_module(meta_name, {
+            module_info = mods.get_module(meta_name) or {
                 "status": True,
-                "info": moduleInfo
-            })
-        logger.debug("所有模块信息已加载并存储到数据库")
-
-        # ==== 实例化 Main 类并挂载到 sdk ====
-        logger.debug("[Init] 开始实例化模块 Main 类...")
-        for module_name in sdkInstalledModuleNames:
-            moduleObj = module_objs[module_name]
-            meta_name = moduleObj.moduleInfo["meta"]["name"]
-
-            module_status = mods.get_module_status(meta_name)
-            if not module_status:
+                "info": moduleObj.moduleInfo
+            }
+            mods.set_module(meta_name, module_info)
+            
+            if not module_info.get('status', True):
+                disabled_modules.append(module_name)
+                logger.warning(f"模块 {meta_name} 已禁用，跳过加载")
                 continue
-
-            moduleMain = moduleObj.Main(sdk)
-            setattr(moduleMain, "moduleInfo", moduleObj.moduleInfo)
-            setattr(sdk, meta_name, moduleMain)
-            logger.debug(f"模块 {meta_name} 正在初始化")
+                
+            _check_dependencies(moduleObj, module_name, os.listdir(module_path))
+            module_objs[module_name] = moduleObj
+            enabled_modules.append(module_name)
+            
+        except Exception as e:
+            logger.warning(f"模块 {module_name} 加载失败: {e}")
+            
+    return module_objs, enabled_modules, disabled_modules
+
+def _validate_module(moduleObj, module_name: str) -> bool:
+    # 验证模块基本结构
+    if not hasattr(moduleObj, "moduleInfo") or not isinstance(moduleObj.moduleInfo, dict):
+        logger.warning(f"模块 {module_name} 缺少有效的 'moduleInfo' 字典")
+        return False
+    if "name" not in moduleObj.moduleInfo.get("meta", {}):
+        logger.warning(f"模块 {module_name} 缺少必要 'name' 键")
+        return False
+    if not hasattr(moduleObj, "Main"):
+        logger.warning(f"模块 {module_name} 缺少 'Main' 类")
+        return False
+    return True
+
+def _check_dependencies(moduleObj, module_name: str, available_modules: list):
+    # 检查模块依赖关系
+    required_deps = moduleObj.moduleInfo.get("dependencies", {}).get("requires", [])
+    if missing := [dep for dep in required_deps if dep not in available_modules]:
+        logger.error(f"模块 {module_name} 缺少必需依赖: {missing}")
+        raiserr.MissingDependencyError(f"模块 {module_name} 缺少必需依赖: {missing}")
+
+    optional_deps = moduleObj.moduleInfo.get("dependencies", {}).get("optional", [])
+    available_optional = [
+        dep for dep in optional_deps 
+        if (isinstance(dep, list) and any(d in available_modules for d in dep)) 
+        or (not isinstance(dep, list) and dep in available_modules)
+    ]
+    if optional_deps and not available_optional:
+        logger.warning(f"模块 {module_name} 缺少所有可选依赖: {optional_deps}")
+
+def _resolve_dependencies(modules: list, module_objs: dict) -> list:
+    # 解析模块依赖关系并进行拓扑排序
+    dependencies = {}
+    for module_name in modules:
+        moduleObj = module_objs[module_name]
+        req_deps = moduleObj.moduleInfo.get("dependencies", {}).get("requires", [])
+        opt_deps = moduleObj.moduleInfo.get("dependencies", {}).get("optional", [])
+        available_opt = [dep for dep in opt_deps if dep in modules]
+        dependencies[module_name] = req_deps + available_opt
+        
+    sorted_modules = sdk.util.topological_sort(modules, dependencies, raiserr.CycleDependencyError)
+    env.set('module_dependencies', {
+        'modules': sorted_modules,
+        'dependencies': dependencies
+    })
+    return sorted_modules
+
+def _register_adapters(modules: list, module_objs: dict) -> bool:
+    # 注册适配器
+    success = True
+    logger.debug("[Init] 开始注册适配器...")
+    for module_name in modules:
+        moduleObj = module_objs[module_name]
+        meta_name = moduleObj.moduleInfo["meta"]["name"]
+        
+        try:
+            if hasattr(moduleObj, "adapterInfo") and isinstance(moduleObj.adapterInfo, dict):
+                for platform, adapter_class in moduleObj.adapterInfo.items():
+                    sdk.adapter.register(platform, adapter_class)
+                    logger.info(f"模块 {meta_name} 注册适配器: {platform}")
+        except Exception as e:
+            logger.error(f"模块 {meta_name} 适配器注册失败: {e}")
+            success = False
+    return success
+
+def _initialize_modules(modules: list, module_objs: dict) -> bool:
+    # 初始化模块
+    success = True
+    logger.debug("[Init] 开始实例化模块...")
+    for module_name in modules:
+        moduleObj = module_objs[module_name]
+        meta_name = moduleObj.moduleInfo["meta"]["name"]
+        
+        try:
+            if mods.get_module_status(meta_name):
+                moduleMain = moduleObj.Main(sdk)
+                setattr(moduleMain, "moduleInfo", moduleObj.moduleInfo)
+                setattr(sdk, meta_name, moduleMain)
+                logger.debug(f"模块 {meta_name} 初始化完成")
+        except Exception as e:
+            logger.error(f"模块 {meta_name} 初始化失败: {e}")
+            success = False
+    return success
+
+def init() -> bool:
+    logger.info("[Init] SDK 正在初始化...")
+    try:
+        if not _prepare_environment():
+            return False
+            
+        module_path = os.path.join(os.path.dirname(__file__), "modules")
+        module_objs, enabled_modules, _ = _scan_modules(module_path)
+        
+        if not enabled_modules:
+            logger.warning("没有找到可用的模块")
+            return True
+            
+        sorted_modules = _resolve_dependencies(enabled_modules, module_objs)
+        if not _register_adapters(sorted_modules, module_objs):
+            return False
+            
+        return _initialize_modules(sorted_modules, module_objs)
+        
     except Exception as e:
+        logger.critical(f"SDK初始化严重错误: {e}")
         raiserr.InitError(f"sdk初始化失败: {e}", exit=True)
+        return False
 
-
-sdk.init = init
+sdk.init = init

ErisPulse/__main__.py

@@ -44,6 +44,7 @@ epsdk origin add https://example.com/map.json
 """
 
 import argparse
+import importlib
 import os
 import sys
 import time
@@ -550,29 +551,27 @@ def install_pip_dependencies(dependencies):
         return False
 
 def install_local_module(module_path, force=False):
-    """安装本地目录中的模块"""
-    module_path = os.path.abspath(module_path)
-    if not os.path.exists(module_path):
-        shellprint.panel(f"路径不存在: {module_path}", "错误", "error")
-        return False
-    
-    # 尝试从目录名获取模块名
-    module_name = os.path.basename(module_path.rstrip('/\\'))
-    
-    # 检查是否是有效的模块目录
-    init_py = os.path.join(module_path, '__init__.py')
-    if not os.path.exists(init_py):
-        shellprint.panel(f"目录 {module_path} 不是一个有效的Python模块", "错误", "error")
-        return False
-    
-    # 尝试导入模块获取moduleInfo
     try:
-        spec = importlib.util.spec_from_file_location(module_name, init_py)
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        if not hasattr(module, 'moduleInfo'):
-            shellprint.panel(f"模块 {module_name} 缺少 moduleInfo 定义", "错误", "error")
+        module_path = os.path.abspath(module_path)
+        if not os.path.exists(module_path):
+            shellprint.panel(f"路径不存在: {module_path}", "错误", "error")
             return False
+        
+        module_name = os.path.basename(module_path.rstrip('/\\'))
+        init_py = os.path.join(module_path, '__init__.py')
+        
+        if not os.path.exists(init_py):
+            shellprint.panel(f"目录 {module_path} 不是一个有效的Python模块", "错误", "error")
+            return False
+        import sys
+        sys.path.insert(0, os.path.dirname(module_path))
+        try:
+            module = importlib.import_module(module_name)
+            if not hasattr(module, 'moduleInfo'):
+                shellprint.panel(f"模块 {module_name} 缺少 moduleInfo 定义", "错误", "error")
+                return False
+        finally:
+            sys.path.remove(os.path.dirname(module_path))
     except Exception as e:
         shellprint.panel(f"导入模块 {module_name} 失败: {e}", "错误", "error")
         return False
@@ -992,7 +991,6 @@ def list_modules(module_name=None):
 
 def main():
     parser = argparse.ArgumentParser(
-        
         prog="epsdk",
         formatter_class=argparse.RawTextHelpFormatter
     )

ErisPulse/adapter.py

@@ -3,13 +3,6 @@
 
 提供平台适配器基类、消息发送DSL和适配器管理功能。支持多平台消息处理、事件驱动和生命周期管理。
 
-## 核心功能
-1. 适配器基类定义
-2. 链式消息发送DSL
-3. 适配器注册和管理
-4. 事件处理系统
-5. 中间件支持
-
 ## API 文档
 
 ### 适配器基类 (BaseAdapter)
@@ -229,124 +222,6 @@ import atexit
 atexit.register(lambda: asyncio.run(sdk.adapter.shutdown()))
 ```
 
-## 最佳实践
-
-1. 适配器实现
-```python
-class MyPlatformAdapter(sdk.BaseAdapter):
-    class Send(sdk.BaseAdapter.Send):
-        # 实现基本消息类型
-        def Text(self, text: str):
-            return asyncio.create_task(
-                self._adapter.call_api(
-                    endpoint="/send",
-                    content=text,
-                    recvId=self._target_id,
-                    recvType=self._target_type
-                )
-            )
-            
-        # 添加自定义消息类型
-        def Image(self, file: bytes):
-            return asyncio.create_task(
-                self._adapter.call_api(
-                    endpoint="/send_image",
-                    file=file,
-                    recvId=self._target_id,
-                    recvType=self._target_type
-                )
-            )
-    
-    async def call_api(self, endpoint: str, **params):
-        # 实现API调用逻辑
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                f"{self.api_base}{endpoint}",
-                json=params
-            ) as response:
-                return await response.json()
-                
-    async def start(self):
-        # 初始化连接
-        self.client = await self._create_client()
-        # 启动事件监听
-        asyncio.create_task(self._listen_events())
-        
-    async def shutdown(self):
-        # 清理资源
-        if self.client:
-            await self.client.close()
-```
-
-2. 事件处理
-```python
-# 注册事件处理器
-adapter = MyPlatformAdapter()
-
-@adapter.on("message")
-async def handle_message(data):
-    # 消息处理逻辑
-    if data["type"] == "text":
-        await process_text_message(data)
-    elif data["type"] == "image":
-        await process_image_message(data)
-
-# 使用中间件
-@adapter.middleware
-async def auth_middleware(data):
-    if not verify_token(data.get("token")):
-        return None
-    return data
-
-@adapter.middleware
-async def log_middleware(data):
-    sdk.logger.info(f"处理事件: {data}")
-    return data
-```
-
-3. 消息发送
-```python
-# 基本消息发送
-async def send_welcome(user_id: str):
-    await sdk.adapter.Platform.Send.To("user", user_id).Text("欢迎！")
-
-# 复杂消息处理
-async def process_group_notification(group_id: str, event: dict):
-    # 发送格式化消息
-    message = format_notification(event)
-    await sdk.adapter.Platform.Send.To("group", group_id).Text(message)
-    
-    # 发送附加文件
-    if event.get("has_attachment"):
-        file_data = await get_attachment(event["attachment_id"])
-        await sdk.adapter.Platform.Send.To("group", group_id).File(file_data)
-```
-
-## 注意事项
-
-1. 适配器实现
-   - 确保正确实现所有抽象方法
-   - 处理所有可能的异常情况
-   - 实现适当的重试机制
-   - 注意资源的正确释放
-
-2. 事件处理
-   - 避免在事件处理器中执行长时间操作
-   - 使用适当的错误处理
-   - 考虑事件处理的顺序性
-   - 合理使用中间件过滤机制
-
-3. 消息发送
-   - 实现消息发送的限流机制
-   - 处理发送失败的情况
-   - 注意消息格式的平台兼容性
-   - 大文件传输时考虑分片
-
-4. 生命周期管理
-   - 确保适配器正确启动和关闭
-   - 处理意外断开的情况
-   - 实现自动重连机制
-   - 注意资源泄漏问题
 """
 
 import functools