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

ErisPulse/__init__.py

@@ -8,12 +8,6 @@
 - 预注册核心错误类型
 - 提供SDK初始化入口
 - 集成各核心模块
-- 支持项目内模块加载（优先于SDK模块）
-
-## 模块加载机制
-- **SDK 内置模块**：位于 `src/ErisPulse/modules/`，会被写入数据库并支持状态管理。
-- **项目自定义模块**：位于项目根目录下的 `modules/`，仅运行时加载，不会写入数据库。
-- **冲突处理**：若同一模块存在于多个路径，选择权重更高的路径（项目模块 > SDK 模块）。
 
 ## API 文档
 ### 核心对象：
@@ -24,13 +18,13 @@
     - CaughtExternalError: 外部捕获异常
     - InitError: 初始化错误
     - MissingDependencyError: 缺少依赖错误  
-    - InvalidDependencyError: 依赖无效错误
+    - InvalidDependencyError: 无效依赖错误
     - CycleDependencyError: 循环依赖错误
     - ModuleLoadError: 模块加载错误
 
 ### 示例用法：
 
-```python
+```
 from ErisPulse import sdk
 
 # 初始化SDK
@@ -42,15 +36,10 @@ sdk.logger.info("SDK已初始化")
 
 """
 
+import types
+sdk = types.SimpleNamespace()
 import os
 import sys
-import logging
-from types import SimpleNamespace
-
-# 初始化全局 sdk 对象
-sdk = SimpleNamespace()
-
-# 导入内部依赖
 from . import util
 from .raiserr import raiserr
 from .logger import logger
@@ -58,220 +47,180 @@ from .db import env
 from .mods import mods
 from .adapter import adapter, BaseAdapter, SendDSL
 
-# Windows 下启用 ANSI 颜色输出
+# 这里不能删，确保windows下的shell能正确显示颜色
 os.system('')
 
-# 挂载基础组件
-for name in ['env', 'mods', 'util', 'raiserr', 'logger', 'adapter', 'SendDSL', 'BaseAdapter']:
-    setattr(sdk, name, eval(name))
-
-# 注册错误类型
-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="模块加载错误")
+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:
     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)
         env.load_env_file()
 
-        # 定义模块路径
-        projectModulePath = os.path.join(os.getcwd(), "modules")  # 项目模块
-        sdkModulePath = os.path.join(os.path.dirname(__file__), "modules")  # SDK 模块
-
-        # 构建模块路径字典（权重控制）
-        modulePaths = {
-            projectModulePath: 100,  # 项目模块优先级更高
-            sdkModulePath: 50        # SDK 内置模块次之
-        }
-
-        # 存储模块名到路径的映射
-        moduleSourceMap = {}  # {module_name: [(path, weight), ...]}
-
-        # 扫描模块并记录来源路径和权重
-        for modulePath, weight in modulePaths.items():
-            if os.path.exists(modulePath) and os.path.isdir(modulePath):
-                modules = [
-                    x for x in os.listdir(modulePath)
-                    if os.path.isdir(os.path.join(modulePath, x))
-                ]
-                for module in modules:
-                    if module not in moduleSourceMap:
-                        moduleSourceMap[module] = []
-                    moduleSourceMap[module].append((modulePath, weight))
-
-        # 处理模块冲突（按权重选择）
-        TempModules = []
-
-        for module, sources in moduleSourceMap.items():
-            if len(sources) > 1:
-                # 按权重排序
-                sources.sort(key=lambda x: x[1], reverse=True)
+        sdkModulePath = os.path.join(os.path.dirname(__file__), "modules")
 
-                selected_path = sources[0][0]
-                logger.warning(f"模块 {module} 在多个路径存在，选择权重更高的: {selected_path}")
+        if not os.path.exists(sdkModulePath):
+            os.makedirs(sdkModulePath)
 
-                # 确保选中的路径在 sys.path 最前面
-                if selected_path in sys.path:
-                    sys.path.remove(selected_path)
-                sys.path.insert(0, selected_path)
+        sys.path.append(sdkModulePath)
 
-            TempModules.append(module)
+        TempModules = [
+            x for x in os.listdir(sdkModulePath)
+            if os.path.isdir(os.path.join(sdkModulePath, x))
+        ]
 
-        # 动态导入模块（不存入数据库）
-        module_objs = {}
+        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' 键.")
+                    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_status = mods.get_module_status(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_status:
+                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 = []
-
-                for dep in required_deps:
-                    dep_name, operator, version = util.parse_dependency_with_version(dep)
-
-                    if dep_name not in TempModules:
-                        missing_required_deps.append(dep)
-                        continue
-
-                    if operator and version:
-                        try:
-                            dep_module = __import__(dep_name)
-                            if not hasattr(dep_module, "moduleInfo"):
-                                missing_required_deps.append(dep)
-                                continue
-
-                            dep_version = dep_module.moduleInfo.get("meta", {}).get("version", "0.0.0")
-                            if not util.check_version_requirement(dep_version, operator, version):
-                                logger.error(
-                                    f"模块 {module_name} 的依赖 {dep_name} 版本不匹配: 需要 {operator}{version}, 实际为 {dep_version}")
-                                missing_required_deps.append(dep)
-                        except Exception as e:
-                            logger.error(f"检查模块 {dep_name} 版本时出错: {e}")
-                            missing_required_deps.append(dep)
-
+                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}")
+                    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:
-                    d_name, operator, version = util.parse_dependency_with_version(dep)
-
-                    if d_name not in TempModules:
-                        continue
-
-                    if operator and version:
-                        try:
-                            d_module = __import__(d_name)
-                            if not hasattr(d_module, "moduleInfo"):
-                                continue
-
-                            d_version = d_module.moduleInfo.get("meta", {}).get("version", "0.0.0")
-                            if not util.check_version_requirement(d_version, operator, version):
-                                logger.warning(
-                                    f"模块 {module_name} 的可选依赖 {d_name} 版本不匹配: 需要 {operator}{version}, 实际为 {d_version}")
-                                continue
-                        except Exception as e:
-                            logger.warning(f"检查模块 {d_name} 版本时出错: {e}")
-                            continue
-
-                    available_optional_deps.append(d_name)
+                    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}")
                 continue
 
-        # ==== 创建 README 提示用户模块目录用途 ====
-        readme_content = """# 项目模块目录
+        # ==== 构建依赖图并进行拓扑排序 ====
+        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", [])
 
-此目录 (`./modules`) 用于存放项目专属模块。这些模块会优先于 SDK 内置模块被加载，但不会写入数据库。
+            available_optional_deps = [dep for dep in opt_deps if dep in sdkInstalledModuleNames]
+            deps = req_deps + available_optional_deps
 
-你可以将自定义模块放入此目录，SDK 会自动识别并加载它们。
-"""
+            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}")
 
-        if not os.path.exists(projectModulePath):
-            os.makedirs(projectModulePath)
+        # ==== 存储模块信息到数据库 ====
+        all_modules_info = {}
+        for module_name in sdkInstalledModuleNames:
+            moduleObj = module_objs[module_name]
+            moduleInfo: dict = moduleObj.moduleInfo
 
-        readme_path = os.path.join(projectModulePath, "README.md")
-        if not os.path.exists(readme_path):
-            with open(readme_path, "w", encoding="utf-8") as f:
-                f.write(readme_content)
-            logger.info(f"您的项目模块目录已创建 | 请查看 {readme_path} 了解如何使用")
+            meta_name = moduleInfo.get("meta", {}).get("name", None)
+            module_info = mods.get_module(meta_name)
+            mods.set_module(meta_name, {
+                "status": True,
+                "info": moduleInfo
+            })
+        logger.debug("所有模块信息已加载并存储到数据库")
 
         # ==== 实例化 Main 类并挂载到 sdk ====
         logger.debug("[Init] 开始实例化模块 Main 类...")
-
-        for module_name in module_objs:
+        for module_name in sdkInstalledModuleNames:
             moduleObj = module_objs[module_name]
             meta_name = moduleObj.moduleInfo["meta"]["name"]
 
-            # 获取模块路径来源
-            source_path = None
-            for path, _ in moduleSourceMap.get(module_name, []):
-                if module_name in os.listdir(path) and os.path.isdir(os.path.join(path, module_name)):
-                    source_path = path
-                    break
-            
-            # 判断是否是 SDK 模块（来自 sdkModulePath）
-            is_sdk_module = source_path == sdkModulePath
-
-            # 如果是 SDK 模块，检查是否已注册到数据库
-            if is_sdk_module:
-                module_info = mods.get_module(meta_name)
-                if module_info is None:
-                    # 首次加载，写入数据库
-                    mods.set_module(meta_name, {
-                        "status": True,
-                        "info": moduleObj.moduleInfo
-                    })
-                    logger.info(f"模块 {meta_name} 信息已初始化并存储到数据库")
-                else:
-                    logger.debug(f"模块 {meta_name} 已存在于数据库中")
+            module_status = mods.get_module_status(meta_name)
+            if not module_status:
+                continue
 
-            # 实例化模块
             moduleMain = moduleObj.Main(sdk)
             setattr(moduleMain, "moduleInfo", moduleObj.moduleInfo)
             setattr(sdk, meta_name, moduleMain)
             logger.debug(f"模块 {meta_name} 正在初始化")
-
     except Exception as e:
         raiserr.InitError(f"sdk初始化失败: {e}", exit=True)
 
+
 sdk.init = init

ErisPulse/__main__.py

@@ -549,7 +549,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:

ErisPulse/util.py

@@ -1,379 +1,51 @@
 """
 # 工具函数集合
 
-提供各种实用工具函数和装饰器，简化开发流程。包括依赖关系处理、性能优化、异步执行和错误重试等功能。
-
-## 核心功能
-1. 依赖关系管理
-2. 函数结果缓存
-3. 异步执行支持
-4. 自动重试机制
-5. 可视化工具
-6. 版本管理和比较
-
+提供各种实用工具函数和装饰器，简化开发流程。
 
 ## API 文档
+### 拓扑排序：
+    - topological_sort(elements, dependencies, error): 拓扑排序依赖关系
+    - show_topology(): 可视化模块依赖关系
 
-### 依赖关系处理
-#### topological_sort(elements: list, dependencies: dict, error: callable) -> list
-对元素进行拓扑排序，解析依赖关系。
-- 参数:
-  - elements: 需要排序的元素列表
-  - dependencies: 依赖关系字典，键为元素，值为该元素依赖的元素列表
-  - error: 发生循环依赖时调用的错误处理函数
-- 返回:
-  - list: 排序后的元素列表
-- 异常:
-  - 当存在循环依赖时，调用error函数
-- 示例:
-```python
-# 基本使用
-modules = ["ModuleA", "ModuleB", "ModuleC"]
-dependencies = {
-    "ModuleB": ["ModuleA"],
-    "ModuleC": ["ModuleB"]
-}
-sorted_modules = sdk.util.topological_sort(modules, dependencies, sdk.raiserr.CycleDependencyError)
+### 装饰器：
+    - @cache: 缓存函数结果
+    - @run_in_executor: 将同步函数转为异步
+    - @retry(max_attempts=3, delay=1): 失败自动重试
 
-# 复杂依赖处理
-modules = ["Database", "Cache", "API", "UI"]
-dependencies = {
-    "Cache": ["Database"],
-    "API": ["Database", "Cache"],
-    "UI": ["API"]
-}
-try:
-    sorted_modules = sdk.util.topological_sort(
-        modules, 
-        dependencies,
-        sdk.raiserr.CycleDependencyError
-    )
-    print("加载顺序:", sorted_modules)
-except Exception as e:
-    print(f"依赖解析失败: {e}")
-```
+### 异步执行：
+    - ExecAsync(async_func, *args, **kwargs): 异步执行函数
 
-#### show_topology() -> str
-可视化显示当前模块的依赖关系。
-- 参数: 无
-- 返回:
-  - str: 格式化的依赖关系树文本
-- 示例:
-```python
-# 显示所有模块依赖
-topology = sdk.util.show_topology()
-print(topology)
+### 示例用法：
 
-# 在日志中记录依赖关系
-sdk.logger.info("模块依赖关系:\n" + sdk.util.show_topology())
 ```
+from ErisPulse import sdk
 
-### 性能优化装饰器
-#### @cache
-缓存函数调用结果的装饰器。
-- 参数: 无
-- 返回:
-  - function: 被装饰的函数
-- 示例:
-```python
-# 缓存计算密集型函数结果
-@sdk.util.cache
-def calculate_complex_data(param1: int, param2: str) -> dict:
-    # 复杂计算...
-    return result
-
-# 缓存配置读取
-@sdk.util.cache
-def get_config(config_name: str) -> dict:
-    return load_config_from_file(config_name)
+# 拓扑排序
+sorted_modules = sdk.util.topological_sort(modules, dependencies, error)
 
-# 带有可变参数的缓存
+# 缓存装饰器
 @sdk.util.cache
-def process_data(*args, **kwargs) -> Any:
-    return complex_processing(args, kwargs)
-```
-
-### 异步执行工具
-#### @run_in_executor
-将同步函数转换为异步执行的装饰器。
-- 参数: 无
-- 返回:
-  - function: 异步包装的函数
-- 示例:
-```python
-# 包装同步IO操作
-@sdk.util.run_in_executor
-def read_large_file(file_path: str) -> str:
-    with open(file_path, 'r') as f:
-        return f.read()
-
-# 包装CPU密集型操作
-@sdk.util.run_in_executor
-def process_image(image_data: bytes) -> bytes:
-    # 图像处理...
-    return processed_data
-
-# 在异步环境中使用
-async def main():
-    # 这些操作会在线程池中执行，不会阻塞事件循环
-    file_content = await read_large_file("large_file.txt")
-    processed_image = await process_image(image_data)
-```
-
-#### ExecAsync(async_func: Callable, *args, **kwargs) -> Any
-在当前线程中执行异步函数。
-- 参数:
-  - async_func: 要执行的异步函数
-  - *args: 传递给异步函数的位置参数
-  - **kwargs: 传递给异步函数的关键字参数
-- 返回:
-  - Any: 异步函数的执行结果
-- 示例:
-```python
-# 在同步环境中执行异步函数
-async def fetch_data(url: str) -> dict:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url) as response:
-            return await response.json()
-
-# 同步环境中调用
-result = sdk.util.ExecAsync(fetch_data, "https://api.example.com/data")
-
-# 批量异步操作
-async def process_multiple(items: list) -> list:
-    results = []
-    for item in items:
-        result = await process_item(item)
-        results.append(result)
-    return results
-
-# 在同步代码中执行
-results = sdk.util.ExecAsync(process_multiple, items_list)
-```
-
-### 错误重试机制
-#### @retry(max_attempts: int = 3, delay: int = 1)
-为不稳定的操作添加自动重试机制的装饰器。
-- 参数:
-  - max_attempts: 最大重试次数，默认3次
-  - delay: 重试间隔时间（秒），默认1秒
-- 返回:
-  - function: 包装了重试逻辑的函数
-- 示例:
-```python
-# 基本重试
-@sdk.util.retry()
-def unstable_network_call() -> dict:
-    return requests.get("https://api.example.com/data").json()
-
-# 自定义重试参数
-@sdk.util.retry(max_attempts=5, delay=2)
-def connect_database() -> Connection:
-    return create_database_connection()
-
-# 带有条件的重试
-@sdk.util.retry(max_attempts=3)
-def process_with_retry(data: dict) -> bool:
-    if not validate_data(data):
-        raise ValueError("Invalid data")
-    return process_data(data)
-```
-
-### 版本管理工具
-#### parse_dependency_with_version(dependency_str: str) -> tuple
-解析带有版本要求的依赖字符串。
-- 参数:
-  - dependency_str: 依赖字符串，如 "ModuleA==1.0.0", "ModuleB>=2.0.0"
-- 返回:
-  - tuple: (模块名, 操作符, 版本号) 或 (模块名, None, None)
-- 示例:
-```python
-# 解析带版本要求的依赖
-module_name, operator, version = sdk.util.parse_dependency_with_version("ModuleA==1.0.0")
-print(f"模块: {module_name}, 操作符: {operator}, 版本: {version}")
-# 输出: 模块: ModuleA, 操作符: ==, 版本: 1.0.0
-
-# 解析不带版本要求的依赖
-module_name, operator, version = sdk.util.parse_dependency_with_version("ModuleB")
-print(f"模块: {module_name}, 操作符: {operator}, 版本: {version}")
-# 输出: 模块: ModuleB, 操作符: None, 版本: None
-```
-
-#### compare_versions(version1: str, version2: str) -> int
-比较两个版本号。
-- 参数:
-  - version1: 第一个版本号字符串，如 "1.0.0"
-  - version2: 第二个版本号字符串，如 "2.0.0"
-- 返回:
-  - int: 如果 version1 < version2 返回 -1，如果 version1 == version2 返回 0，如果 version1 > version2 返回 1
-- 示例:
-```python
-# 比较版本号
-result = sdk.util.compare_versions("1.0.0", "2.0.0")
-print(f"比较结果: {result}")  # 输出: 比较结果: -1
-
-result = sdk.util.compare_versions("2.0.0", "2.0.0")
-print(f"比较结果: {result}")  # 输出: 比较结果: 0
-
-result = sdk.util.compare_versions("2.1.0", "2.0.5")
-print(f"比较结果: {result}")  # 输出: 比较结果: 1
-```
-
-#### check_version_requirement(current_version: str, operator: str, required_version: str) -> bool
-检查当前版本是否满足版本要求。
-- 参数:
-  - current_version: 当前版本号字符串，如 "1.0.0"
-  - operator: 操作符，如 "==", ">=", "<="
-  - required_version: 要求的版本号字符串，如 "2.0.0"
-- 返回:
-  - bool: 如果满足要求返回 True，否则返回 False
-- 示例:
-```python
-# 检查版本要求
-result = sdk.util.check_version_requirement("1.0.0", "==", "1.0.0")
-print(f"版本匹配: {result}")  # 输出: 版本匹配: True
-
-result = sdk.util.check_version_requirement("1.5.0", ">=", "1.0.0")
-print(f"版本匹配: {result}")  # 输出: 版本匹配: True
-
-result = sdk.util.check_version_requirement("2.0.0", "<", "1.0.0")
-print(f"版本匹配: {result}")  # 输出: 版本匹配: False
-```
-
-## 最佳实践
-1. 依赖管理
-```python
-# 模块依赖定义
-module_deps = {
-    "core": [],
-    "database": ["core"],
-    "api": ["database"],
-    "ui": ["api"]
-}
-
-# 验证并排序依赖
-try:
-    load_order = sdk.util.topological_sort(
-        list(module_deps.keys()),
-        module_deps,
-        sdk.raiserr.CycleDependencyError
-    )
+def expensive_operation(param):
+    return heavy_computation(param)
     
-    # 按顺序加载模块
-    for module in load_order:
-        load_module(module)
-except Exception as e:
-    sdk.logger.error(f"模块加载失败: {e}")
-```
-
-2. 性能优化
-```python
-# 合理使用缓存
-@sdk.util.cache
-def get_user_preferences(user_id: str) -> dict:
-    return database.fetch_user_preferences(user_id)
-
-# 异步处理耗时操作
-@sdk.util.run_in_executor
-def process_large_dataset(data: list) -> list:
-    return [complex_calculation(item) for item in data]
-```
-
-3. 错误处理和重试
-```python
-# 组合使用重试和异步
-@sdk.util.retry(max_attempts=3, delay=2)
+# 异步执行
 @sdk.util.run_in_executor
-def reliable_network_operation():
-    response = requests.get("https://api.example.com")
-    response.raise_for_status()
-    return response.json()
-
-# 带有自定义错误处理的重试
-@sdk.util.retry(max_attempts=5)
-def safe_operation():
-    try:
-        return perform_risky_operation()
-    except Exception as e:
-        sdk.logger.warning(f"操作失败，准备重试: {e}")
-        raise
-```
-
-4. 版本管理
-```python
-# 在模块中定义依赖
-moduleInfo = {
-    "meta": {
-        "name": "AdvancedFeatures",
-        "version": "1.2.0"
-    },
-    "dependencies": {
-        "requires": [
-            "CoreModule>=1.0.0",
-            "DatabaseModule==2.1.0"
-        ],
-        "optional": [
-            "VisualizationModule>=1.5.0",
-            ["CacheModule>2.0.0", "FastCacheModule>=1.0.0"]
-        ]
-    }
-}
-
-# 手动检查版本兼容性
-def check_plugin_compatibility(plugin_info):
-    required_version = "2.0.0"
-    plugin_version = plugin_info.get("version", "0.0.0")
+def sync_task():
+    pass
     
-    if sdk.util.check_version_requirement(plugin_version, ">=", required_version):
-        sdk.logger.info(f"插件 '{plugin_info['name']}' 版本兼容")
-        return True
-    else:
-        sdk.logger.warning(f"插件 '{plugin_info['name']}' 版本 {plugin_version} 不兼容，需要 >={required_version}")
-        return False
-        
-# 解析带版本要求的依赖字符串
-def process_dependency(dependency_str):
-    module_name, operator, version = sdk.util.parse_dependency_with_version(dependency_str)
-    if operator and version:
-        return f"需要模块 {module_name} {operator}{version}"
-    else:
-        return f"需要模块 {module_name}，无版本要求"
+# 重试机制
+@sdk.util.retry(max_attempts=3, delay=1)
+def unreliable_operation():
+    pass
 ```
 
-## 注意事项
-1. 缓存使用
-   - 注意内存占用，避免缓存过大数据
-   - 考虑缓存失效策略
-   - 不要缓存频繁变化的数据
-
-2. 异步执行
-   - 避免在 run_in_executor 中执行过长的操作
-   - 注意异常处理和资源清理
-   - 合理使用线程池
-
-3. 重试机制
-   - 设置合适的重试次数和间隔
-   - 只对可重试的操作使用重试装饰器
-   - 注意避免重试导致的资源浪费
-
-4. 依赖管理
-   - 保持依赖关系清晰简单
-   - 避免循环依赖
-   - 定期检查和更新依赖关系
-
-5. 版本管理
-   - 遵循语义化版本规范（主版本.次版本.修订版本）
-   - 明确指定版本要求，避免使用过于宽松的版本约束
-   - 在主版本更新时，注意可能的不兼容变更
-   - 测试不同版本依赖组合的兼容性
-   - 为模块提供明确的版本号和更新日志
 """
 
 import time
 import asyncio
 import functools
 import traceback
-import re
 from concurrent.futures import ThreadPoolExecutor
 from collections import defaultdict, deque
 
@@ -468,53 +140,4 @@ def retry(max_attempts=3, delay=1):
                         raise
                     time.sleep(delay)
         return wrapper
-    return decorator
-
-def parse_dependency_with_version(dependency_str):
-    pattern = r'^([a-zA-Z0-9_\-]+)(?:([=<>!]+)([0-9]+(?:\.[0-9]+)*))?\s**$'
-    match = re.match(pattern, dependency_str)
-    
-    if not match:
-        return dependency_str, None, None
-    
-    module_name, operator, version = match.groups()
-    return module_name, operator, version
-
-def compare_versions(version1, version2):
-    v1_parts = [int(x) for x in version1.split('.')]
-    v2_parts = [int(x) for x in version2.split('.')]
-    
-    # 确保两个版本号有相同的部分数
-    while len(v1_parts) < len(v2_parts):
-        v1_parts.append(0)
-    while len(v2_parts) < len(v1_parts):
-        v2_parts.append(0)
-    
-    for i in range(len(v1_parts)):
-        if v1_parts[i] < v2_parts[i]:
-            return -1
-        elif v1_parts[i] > v2_parts[i]:
-            return 1
-    
-    return 0
-
-def check_version_requirement(current_version, operator, required_version):
-    if not operator or not required_version:
-        return True
-    
-    comparison = compare_versions(current_version, required_version)
-    
-    if operator == '==':
-        return comparison == 0
-    elif operator == '!=':
-        return comparison != 0
-    elif operator == '>':
-        return comparison > 0
-    elif operator == '>=':
-        return comparison >= 0
-    elif operator == '<':
-        return comparison < 0
-    elif operator == '<=':
-        return comparison <= 0
-    
-    return False
+    return decorator

{erispulse-1.1.14.dist-info → erispulse-1.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErisPulse
-Version: 1.1.14
+Version: 1.1.15
 Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
 Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>, runoneall <runoobsteve@gmail.com>
 License: MIT License

erispulse-1.1.15.dist-info/RECORD

@@ -0,0 +1,13 @@
+ErisPulse/__init__.py,sha256=k-X8WV9sIrYeYDNb8qZyBZ8s8yNL2bKWhZdkPbzRWII,8936
+ErisPulse/__main__.py,sha256=KHBHedKC2bYWeqOi2rENgv_l5Pz-d2y7Bf4ST3R0TY4,52862
+ErisPulse/adapter.py,sha256=3DayPbvWit2D8DTLIvhbP3862arv2UZuAkFnE9QWGro,17479
+ErisPulse/db.py,sha256=a_5uTQk8w2TDp6J6AIQ4rF8Z2IvswuSg8q-Tx0SHfGA,24900
+ErisPulse/logger.py,sha256=np6H4-x3xNpmoOGou5znsfv-iVlX56cVrsX8446cY-M,14764
+ErisPulse/mods.py,sha256=oDVgEh56IUTLZDIxxWTQe5QvQSyWVAb8vhgd1fzFlYo,12253
+ErisPulse/raiserr.py,sha256=Un8VGcVYDOSi7ptRVmyBzUTW7mQzDatqIza6919dQ1w,7034
+ErisPulse/util.py,sha256=tmmZA4Ef5ElB01KZg2fTZLrkZOJbORjnkAd8sXj7xqw,4335
+erispulse-1.1.15.dist-info/METADATA,sha256=4gCjt0C4F_qGRW3rKd0Rn9n2Tr9liDB0eCslFwex7zY,5877
+erispulse-1.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-1.1.15.dist-info/entry_points.txt,sha256=y8ppdsQhk-azC7_ikQgRr4rITSZ4VC4crVKtzHh4TBY,146
+erispulse-1.1.15.dist-info/licenses/LICENSE,sha256=plj4EYVfKAzc0ZWoC5T2vsQ86u0yLpu17NdAPeIcgVo,1066
+erispulse-1.1.15.dist-info/RECORD,,

{erispulse-1.1.14.dist-info → erispulse-1.1.15.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
-ErisPulse = ErisPulse.__main__:main
-ErisPulse-CLI = ErisPulse.__main__:main
 ep = ErisPulse.__main__:main
+ep-cli = ErisPulse.__main__:main
+ep-init = ErisPulse.__init__:init
 epsdk = ErisPulse.__main__:main

erispulse-1.1.14.dist-info/RECORD

@@ -1,13 +0,0 @@
-ErisPulse/__init__.py,sha256=14y4ywMLOCN-w35UDpERJ-deV2DR0olZFcjY68hzeXw,11188
-ErisPulse/__main__.py,sha256=CVk0bCv5zgJZKA7_LLyYOQCxPFUzTwhkOYVqf3M1YQE,50187
-ErisPulse/adapter.py,sha256=3DayPbvWit2D8DTLIvhbP3862arv2UZuAkFnE9QWGro,17479
-ErisPulse/db.py,sha256=a_5uTQk8w2TDp6J6AIQ4rF8Z2IvswuSg8q-Tx0SHfGA,24900
-ErisPulse/logger.py,sha256=np6H4-x3xNpmoOGou5znsfv-iVlX56cVrsX8446cY-M,14764
-ErisPulse/mods.py,sha256=oDVgEh56IUTLZDIxxWTQe5QvQSyWVAb8vhgd1fzFlYo,12253
-ErisPulse/raiserr.py,sha256=Un8VGcVYDOSi7ptRVmyBzUTW7mQzDatqIza6919dQ1w,7034
-ErisPulse/util.py,sha256=oa31SrzH-54exEgUhqkWxZuYScErl-rE7StDH4rkG3Y,15629
-erispulse-1.1.14.dist-info/METADATA,sha256=MllU6eXjXF97rohrAKZul81ZYcKXZXYcjgJWOwa-xiA,5877
-erispulse-1.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-1.1.14.dist-info/entry_points.txt,sha256=AjKvOdYR7QGXVpEJhjUYUwV2JluE4lm9vNbknC3hjOM,155
-erispulse-1.1.14.dist-info/licenses/LICENSE,sha256=plj4EYVfKAzc0ZWoC5T2vsQ86u0yLpu17NdAPeIcgVo,1066
-erispulse-1.1.14.dist-info/RECORD,,