ErisPulse 1.1.14.dev1__py3-none-any.whl → 1.1.16__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,199 @@ 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:
+        raiserr.register(error, doc=doc)
+    except Exception as e:
+        raise e
+
+def _prepare_environment() -> bool:
+    # 检查环境
+    logger.info("[Init] 准备初始化环境...")
     try:
-        logger.info("[Init] SDK 正在初始化...")
         if env.create_env_file_if_not_exists():
             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
@@ -549,7 +550,74 @@ def install_pip_dependencies(dependencies):
         shellprint.panel(f"安装pip依赖失败: {e.stderr}", "错误", "error")
         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")
+            return False
+    except Exception as e:
+        shellprint.panel(f"导入模块 {module_name} 失败: {e}", "错误", "error")
+        return False
+    
+    module_info = mods.get_module(module_name)
+    if module_info and not force:
+        meta = module_info.get('info', {}).get('meta', {})
+        shellprint.panel(
+            f"{Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}\n版本: {meta.get('version', '未知')}\n描述: {meta.get('description', '无描述')}",
+            "模块已存在",
+            "info"
+        )
+        if not shellprint.confirm("是否要强制重新安装？", default=False):
+            return False
+    
+    # 复制模块到modules目录
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    target_dir = os.path.join(script_dir, 'modules', module_name)
+    
+    try:
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+        shutil.copytree(module_path, target_dir)
+    except Exception as e:
+        shellprint.panel(f"复制模块文件失败: {e}", "错误", "error")
+        return False
+    
+    # 注册模块信息
+    mods.set_module(module_name, {
+        'status': True,
+        'info': {
+            'meta': module.moduleInfo.get('meta', {}),
+            'dependencies': module.moduleInfo.get('dependencies', {})
+        }
+    })
+    
+    shellprint.panel(f"本地模块 {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET} 安装成功", "成功", "success")
+    return True
+
 def install_module(module_name, force=False):
+    # 检查是否是本地路径
+    if module_name.startswith('.') or os.path.isabs(module_name):
+        return install_local_module(module_name, force)
+        
     shellprint.panel(f"准备安装模块: {Shell_Printer.BOLD}{module_name}{Shell_Printer.RESET}", "安装摘要", "info")
     last_update_time = env.get('last_origin_update_time', None)
     if last_update_time:
@@ -925,7 +993,6 @@ def list_modules(module_name=None):
 
 def main():
     parser = argparse.ArgumentParser(
-        
         prog="epsdk",
         formatter_class=argparse.RawTextHelpFormatter
     )
@@ -1147,7 +1214,12 @@ def main():
         else:
             shellprint.panel(f"运行脚本: {Shell_Printer.BOLD}{script_path}{Shell_Printer.RESET}", "执行", "info")
             import runpy
-            runpy.run_path(script_path, run_name="__main__")
+
+            # 添加KeyboardInterrupt异常捕捉
+            try:
+                runpy.run_path(script_path, run_name="__main__")
+            except KeyboardInterrupt:
+                shellprint.panel("脚本执行已中断", "中断", "info")
             
     elif args.command == 'origin':
         if args.origin_command == 'add':