ErisPulse 1.1.15__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
@@ -992,7 +993,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

ErisPulse/db.py

@@ -3,13 +3,6 @@
 
 提供键值存储、事务支持、快照和恢复功能，用于管理框架配置数据。基于SQLite实现持久化存储，支持复杂数据类型和原子操作。
 
-## 核心功能
-1. 键值存储
-2. 事务支持
-3. 数据库快照
-4. 自动备份
-5. 配置文件集成
-
 ## API 文档
 
 ### 基本操作
@@ -431,27 +424,6 @@ def safe_bulk_update(updates):
         raise
 ```
 
-## 注意事项
-
-1. 性能优化
-   - 使用批量操作代替多次单独操作
-   - 合理使用事务减少数据库操作次数
-   - 避免存储过大的值，考虑分片存储
-
-2. 数据安全
-   - 定期创建快照备份重要数据
-   - 使用事务确保数据一致性
-   - 不要存储敏感信息（如密码）的明文
-
-3. 配置管理
-   - 使用有意义的键名和层次结构
-   - 记录配置的更新历史
-   - 定期清理不再使用的配置
-
-4. 错误处理
-   - 所有数据库操作都应该有错误处理
-   - 重要操作前创建快照以便回滚
-   - 记录所有关键操作的日志
 """
 
 import os

ErisPulse/logger.py

@@ -3,62 +3,16 @@
 
 提供模块化、多级别的日志记录功能，支持内存存储和文件输出。实现了模块级别的日志控制、彩色输出和灵活的存储选项。
 
-## 核心功能
-1. 多级别日志记录
-2. 模块级别日志控制
-3. 内存日志存储
-4. 文件输出支持
-5. 自动调用者识别
-6. 异常捕获装饰器
-
 ## API 文档
 
 ### 基本日志操作
-#### debug(msg: str, *args, **kwargs) -> None
-记录调试级别的日志信息。
-- 参数:
-  - msg: 日志消息
-  - *args: 传递给底层logger的位置参数
-  - **kwargs: 传递给底层logger的关键字参数
-- 返回:
-  - None
-- 示例:
-```python
-# 基本调试信息
-sdk.logger.debug("初始化配置")
 
-# 带有变量的调试信息
-config_value = get_config("timeout")
-sdk.logger.debug(f"读取配置: timeout = {config_value}")
+以debug为例：
+> 此外，还有其他级别的日志记录函数，如info, warning, error, critical等，用法相同。
 
-# 在条件下记录调试信息
-if is_development_mode():
-    sdk.logger.debug("开发模式下的详细信息: %s", detailed_info)
-```
-
-#### info(msg: str, *args, **kwargs) -> None
-记录信息级别的日志信息。
-- 参数:
-  - msg: 日志消息
-  - *args: 传递给底层logger的位置参数
-  - **kwargs: 传递给底层logger的关键字参数
-- 返回:
-  - None
-- 示例:
-```python
-# 基本信息记录
-sdk.logger.info("应用已启动")
+debug(msg: str, *args, **kwargs) -> None
 
-# 带有上下文的信息
-user_count = get_active_users()
-sdk.logger.info(f"当前活跃用户: {user_count}")
-
-# 记录操作结果
-sdk.logger.info("数据导入完成，共处理 %d 条记录", record_count)
-```
-
-#### warning(msg: str, *args, **kwargs) -> None
-记录警告级别的日志信息。
+记录调试级别的日志信息。
 - 参数:
   - msg: 日志消息
   - *args: 传递给底层logger的位置参数
@@ -66,64 +20,9 @@ sdk.logger.info("数据导入完成，共处理 %d 条记录", record_count)
 - 返回:
   - None
 - 示例:
-```python
-# 基本警告信息
-sdk.logger.warning("配置文件未找到，使用默认配置")
 
-# 性能警告
-if response_time > threshold:
-    sdk.logger.warning(f"响应时间过长: {response_time}ms > {threshold}ms")
-
-# 资源使用警告
-memory_usage = get_memory_usage()
-if memory_usage > 80:
-    sdk.logger.warning("内存使用率高: %d%%", memory_usage)
-```
-
-#### error(msg: str, *args, **kwargs) -> None
-记录错误级别的日志信息。
-- 参数:
-  - msg: 日志消息
-  - *args: 传递给底层logger的位置参数
-  - **kwargs: 传递给底层logger的关键字参数
-- 返回:
-  - None
-- 示例:
 ```python
-# 基本错误信息
-sdk.logger.error("数据库连接失败")
-
-# 带有异常信息的错误
-try:
-    process_data()
-except Exception as e:
-    sdk.logger.error(f"数据处理错误: {str(e)}")
-
-# 带有错误代码的错误
-sdk.logger.error("API请求失败，状态码: %d, 错误: %s", status_code, error_message)
-```
-
-#### critical(msg: str, *args, **kwargs) -> None
-记录致命错误级别的日志信息，并终止程序。
-- 参数:
-  - msg: 日志消息
-  - *args: 传递给底层logger的位置参数
-  - **kwargs: 传递给底层logger的关键字参数
-- 返回:
-  - None (程序会终止)
-- 示例:
-```python
-# 致命错误记录
-if not database_connection:
-    sdk.logger.critical("无法连接到主数据库，应用无法继续运行")
-
-# 安全相关的致命错误
-if security_breach_detected():
-    sdk.logger.critical("检测到安全漏洞，强制关闭系统")
-
-# 资源耗尽的致命错误
-if disk_space < min_required:
-    sdk.logger.critical("磁盘空间不足 (%dMB)，无法继续运行", disk_space)
+sdk.logger.debug("这是一条日志")
 ```
 
 ### 日志级别控制
@@ -214,118 +113,11 @@ import atexit
 atexit.register(lambda: sdk.logger.save_logs("final_logs.txt"))
 ```
 
-### 异常捕获 (准备弃用)
-#### catch(func_or_level=None, level="error")
-异常捕获装饰器。
-- 参数:
-  - func_or_level: 要装饰的函数或日志级别
-  - level: 捕获异常时使用的日志级别
-- 返回:
-  - function: 装饰后的函数
-- 注意:
-  - 此功能已集成到 raiserr 模块中，建议使用 raiserr 进行异常处理
-- 示例:
-```python
-# 基本用法 (不推荐，请使用raiserr)
-@sdk.logger.catch
-def risky_function():
-    # 可能抛出异常的代码
-    process_data()
-
-# 指定日志级别 (不推荐，请使用raiserr)
-@sdk.logger.catch(level="critical")
-def very_important_function():
-    # 关键操作
-    update_database()
-```
-
-## 最佳实践
-1. 日志级别使用
-```python
-# 开发环境使用详细日志
-if is_development():
-    sdk.logger.set_level("DEBUG")
-    sdk.logger.debug("详细的调试信息")
-else:
-    sdk.logger.set_level("INFO")
-    
-# 性能敏感模块使用更高级别
-sdk.logger.set_module_level("PerformanceModule", "WARNING")
-```
-
-2. 结构化日志信息
-```python
-# 使用一致的格式
-def log_api_request(endpoint, method, status, duration):
-    sdk.logger.info(
-        f"API请求: {method} {endpoint} - 状态: {status}, 耗时: {duration}ms"
-    )
-
-# 包含关键上下文
-def log_user_action(user_id, action, result):
-    sdk.logger.info(
-        f"用户操作: [用户:{user_id}] {action} - 结果: {result}"
-    )
-```
-
-3. 日志文件管理
-```python
-# 按日期分割日志文件
-from datetime import datetime
-import os
-
-def setup_logging():
-    log_dir = "logs"
-    os.makedirs(log_dir, exist_ok=True)
-    
-    today = datetime.now().strftime("%Y-%m-%d")
-    log_file = os.path.join(log_dir, f"app_{today}.log")
-    
-    sdk.logger.set_output_file(log_file)
-    sdk.logger.info(f"日志文件已设置: {log_file}")
-```
-
-4. 异常处理与日志
-```python
-# 推荐方式：使用raiserr结合logger
-def process_with_logging():
-    try:
-        result = perform_operation()
-        sdk.logger.info(f"操作成功: {result}")
-        return result
-    except Exception as e:
-        sdk.logger.error(f"操作失败: {str(e)}")
-        sdk.raiserr.OperationError(f"处理失败: {str(e)}")
-```
-
-## 注意事项
-1. 日志级别选择
-   - DEBUG: 详细的调试信息，仅在开发环境使用
-   - INFO: 常规操作信息，适用于生产环境
-   - WARNING: 潜在问题或异常情况
-   - ERROR: 错误但不影响整体功能
-   - CRITICAL: 致命错误，导致程序终止
-
-2. 性能考虑
-   - 避免在高频循环中记录过多日志
-   - 使用适当的日志级别减少不必要的输出
-   - 考虑日志文件大小和轮转策略
-
-3. 敏感信息保护
-   - 不要记录密码、令牌等敏感信息
-   - 在记录用户数据前进行脱敏处理
-   - 遵循数据保护法规要求
-
-4. 迁移建议
-   - 从catch装饰器迁移到raiserr模块
-   - 使用结构化的错误处理方式
-   - 结合日志和错误管理实现完整的异常处理流程
 """
 
 import logging
 import inspect
 import datetime
-import functools
 
 class Logger:
     def __init__(self):
@@ -395,34 +187,6 @@ class Logger:
                 self._logger.error(f"无法保存日志到 {p}: {e}。")
                 raise e
 
-    def catch(self, func_or_level=None, level="error"):
-        if isinstance(func_or_level, str):
-            return lambda func: self.catch(func, level=func_or_level)
-        if func_or_level is None:
-            return lambda func: self.catch(func, level=level)
-        func = func_or_level
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                import traceback
-                error_info = traceback.format_exc()
-
-                module_name = func.__module__
-                if module_name == "__main__":
-                    module_name = "Main"
-                func_name = func.__name__
-
-                error_msg = f"Exception in {func_name}: {str(e)}\n{error_info}"
-
-                log_method = getattr(self, level, self.error)
-                log_method(error_msg)
-
-                return None
-        return wrapper
-
     def _save_in_memory(self, ModuleName, msg):
         if ModuleName not in self._logs:
             self._logs[ModuleName] = []
@@ -441,6 +205,8 @@ class Logger:
             module_name = "Main"
         if module_name.endswith(".Core"):
             module_name = module_name[:-5]
+        if module_name.startswith("ErisPulse"):
+            module_name = "ErisPulse"
         return module_name
 
     def debug(self, msg, *args, **kwargs):

ErisPulse/mods.py

@@ -3,13 +3,6 @@
 
 提供模块的注册、状态管理和依赖解析功能。支持模块信息存储、状态切换和批量操作。
 
-## 核心功能
-1. 模块信息管理
-2. 模块状态控制
-3. 批量模块操作
-4. 存储前缀自定义
-5. 模块依赖管理
-
 ## API 文档
 
 ### 模块状态管理
@@ -257,76 +250,6 @@ custom_status_key = f"{sdk.mods.status_prefix}custom.{module_name}"
 sdk.env.set(custom_status_key, is_active)
 ```
 
-## 最佳实践
-1. 模块信息结构
-```python
-# 推荐的模块信息结构
-module_info = {
-    "status": True,  # 模块启用状态
-    "info": {
-        "meta": {
-            "name": "ModuleName",  # 模块名称
-            "version": "1.0.0",    # 模块版本
-            "description": "模块描述",
-            "author": "作者",
-            "license": "MIT",
-            "tags": ["tag1", "tag2"]  # 分类标签
-        },
-        "dependencies": {
-            "requires": ["RequiredModule1"],  # 必需依赖
-            "optional": ["OptionalModule1"],  # 可选依赖
-            "pip": ["package1", "package2"]   # pip包依赖
-        }
-    },
-    "config": {  # 模块配置（可选）
-        "setting1": "value1",
-        "setting2": "value2"
-    }
-}
-```
-
-2. 模块状态管理
-```python
-# 根据条件启用/禁用模块
-def toggle_modules_by_environment():
-    env_type = get_environment_type()
-    
-    # 开发环境启用调试模块
-    if env_type == "development":
-        sdk.mods.set_module_status("DebugModule", True)
-        sdk.mods.set_module_status("PerformanceModule", False)
-    
-    # 生产环境禁用调试模块，启用性能模块
-    elif env_type == "production":
-        sdk.mods.set_module_status("DebugModule", False)
-        sdk.mods.set_module_status("PerformanceModule", True)
-```
-
-3. 模块依赖检查
-```python
-# 检查模块依赖
-def check_module_dependencies(module_name):
-    module_info = sdk.mods.get_module(module_name)
-    if not module_info:
-        return False
-        
-    dependencies = module_info.get("info", {}).get("dependencies", {}).get("requires", [])
-    
-    for dep in dependencies:
-        dep_info = sdk.mods.get_module(dep)
-        if not dep_info or not dep_info.get("status", False):
-            sdk.logger.warning(f"模块 {module_name} 的依赖 {dep} 未启用或不存在")
-            return False
-            
-    return True
-```
-
-## 注意事项
-1. 模块名称应唯一，避免冲突
-2. 模块信息结构应保持一致，便于管理
-3. 更新模块信息前应先获取现有信息，避免覆盖
-4. 批量操作时注意性能影响
-5. 自定义前缀时确保不与系统其他键冲突
 """
 
 import json

ErisPulse/raiserr.py

@@ -3,13 +3,6 @@
 
 提供错误类型注册、抛出和管理功能，集成全局异常处理。支持自定义错误类型、错误链追踪和全局异常捕获。
 
-## 核心功能
-1. 错误类型注册和管理
-2. 动态错误抛出
-3. 全局异常处理
-4. 错误信息追踪
-5. 异步错误处理
-
 ## API 文档
 
 ### 错误注册
@@ -73,87 +66,6 @@ except Exception as e:
     print(f"捕获到错误: {e}")
 ```
 
-### 全局异常处理
-#### global_exception_handler(exc_type: type, exc_value: Exception, exc_traceback: traceback)
-全局同步异常处理器。
-- 参数:
-  - exc_type: 异常类型
-  - exc_value: 异常值
-  - exc_traceback: 异常追踪信息
-- 示例:
-```python
-# 系统会自动捕获未处理的异常
-def risky_operation():
-    raise Exception("未处理的异常")
-    
-# 异常会被global_exception_handler捕获并处理
-risky_operation()
-```
-
-#### async_exception_handler(loop: asyncio.AbstractEventLoop, context: dict)
-全局异步异常处理器。
-- 参数:
-  - loop: 事件循环实例
-  - context: 异常上下文信息
-- 示例:
-```python
-async def async_operation():
-    raise Exception("异步操作错误")
-    
-# 异常会被async_exception_handler捕获并处理
-asyncio.create_task(async_operation())
-```
-
-## 最佳实践
-1. 错误类型注册
-```python
-# 为特定功能模块注册错误类型
-sdk.raiserr.register("DatabaseError", "数据库操作错误")
-sdk.raiserr.register("NetworkError", "网络连接错误")
-sdk.raiserr.register("ValidationError", "数据验证错误")
-
-# 使用继承关系组织错误类型
-class ModuleError(Exception):
-    pass
-sdk.raiserr.register("ConfigError", "配置错误", ModuleError)
-sdk.raiserr.register("PluginError", "插件错误", ModuleError)
-```
-
-2. 错误处理流程
-```python
-def process_data(data):
-    try:
-        if not data:
-            sdk.raiserr.ValidationError("数据不能为空")
-        if not isinstance(data, dict):
-            sdk.raiserr.ValidationError("数据必须是字典类型")
-            
-        # 处理数据...
-        
-    except Exception as e:
-        # 错误会被自动记录并处理
-        sdk.raiserr.ProcessingError(f"数据处理失败: {str(e)}")
-```
-
-3. 异步环境使用
-```python
-async def async_task():
-    try:
-        result = await some_async_operation()
-        if not result.success:
-            sdk.raiserr.AsyncOperationError("异步操作失败")
-    except Exception as e:
-        # 异步错误会被async_exception_handler捕获
-        raise
-```
-
-## 注意事项
-1. 错误类型命名应具有描述性，便于理解错误来源
-2. 错误消息应包含足够的上下文信息，便于调试
-3. 适当使用exit参数，只在致命错误时设置为True
-4. 避免在全局异常处理器中执行耗时操作
-5. 确保异步代码中的错误能够被正确捕获和处理
-
 """
 
 import sys
@@ -209,24 +121,16 @@ raiserr = Error()
 
 # 全局异常处理器
 def global_exception_handler(exc_type, exc_value, exc_traceback):
-    from .logger import logger
     error_message = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
-    logger.error(f"未处理的异常被捕获:\n{error_message}")
-    raiserr.CaughtExternalError(
-        f"检测到外部异常，请优先使用 sdk.raiserr 抛出错误。\n原始异常: {exc_type.__name__}: {exc_value}\nTraceback:\n{error_message}"
+    raiserr.ExternalError(
+        f"{exc_type.__name__}: {exc_value}\nTraceback:\n{error_message}"
     )
-sys.excepthook = global_exception_handler
-
 def async_exception_handler(loop, context):
-    from .logger import logger
     exception = context.get('exception')
-    message = context.get('message', 'Async error')
-    if exception:
-        tb = ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))
-        logger.error(f"异步任务异常: {message}\n{tb}")
-        raiserr.CaughtExternalError(
-            f"检测到异步任务异常，请优先使用 sdk.raiserr 抛出错误。\n原始异常: {type(exception).__name__}: {exception}\nTraceback:\n{tb}"
-        )
-    else:
-        logger.warning(f"异步任务警告: {message}")
+    tb = ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+    raiserr.ExternalError(
+        f"{type(exception).__name__}: {exception}\nTraceback:\n{tb}"
+    )
+
+sys.excepthook = global_exception_handler
 asyncio.get_event_loop().set_exception_handler(async_exception_handler)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErisPulse
-Version: 1.1.15
+Version: 1.1.16
 Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
 Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>, runoneall <runoobsteve@gmail.com>
 License: MIT License
@@ -31,61 +31,68 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: aiohttp
+Requires-Dist: importlib>=1.0.4
 Requires-Dist: watchdog
 Description-Content-Type: text/markdown
 
-![](./.github/assets/erispulse_logo.png)
-**ErisPulse** 是基于 [Framer](https://github.com/FramerOrg/Framer) 构建的异步机器人开发框架。
+# ErisPulse - 异步机器人开发框架
+
+![ErisPulse Logo](.github/assets/erispulse_logo.png)
 
 [![FramerOrg](https://img.shields.io/badge/合作伙伴-FramerOrg-blue?style=flat-square)](https://github.com/FramerOrg)
 [![License](https://img.shields.io/github/license/ErisPulse/ErisPulse?style=flat-square)](https://github.com/ErisPulse/ErisPulse/blob/main/LICENSE)
-
 [![Python Versions](https://img.shields.io/pypi/pyversions/ErisPulse?style=flat-square)](https://pypi.org/project/ErisPulse/)
 
-> 文档站:
-
+> 文档站: 
 [![Docs-Main](https://img.shields.io/badge/docs-main_site-blue?style=flat-square)](https://www.erisdev.com/docs.html)
 [![Docs-CF Pages](https://img.shields.io/badge/docs-cloudflare-blue?style=flat-square)](https://erispulse.pages.dev/docs.html)
 [![Docs-GitHub](https://img.shields.io/badge/docs-github-blue?style=flat-square)](https://erispulse.github.io/docs.html)
 [![Docs-Netlify](https://img.shields.io/badge/docs-netlify-blue?style=flat-square)](https://erispulse.netlify.app/docs.htm)
 
-- [GitHub 社区讨论](https://github.com/ErisPulse/ErisPulse/discussions)
 
-### 框架选型指南
-| 需求          | 推荐框架       | 理由                          |
-|-------------------|----------------|-----------------------------|
-| 轻量化/底层模块化 | [Framer](https://github.com/FramerOrg/Framer) | 高度解耦的模块化设计          |
-| 全功能机器人开发  | ErisPulse      | 开箱即用的完整解决方案        |
+## 核心特性
 
-## ✨ 核心特性
-- ⚡ 完全异步架构设计（async/await）
-- 🧩 模块化插件系统
-- 🔁 支持python热重载
-- 🛑 统一的错误管理
-- 🛠️ 灵活的配置管理
+| 特性 | 描述 |
+|------|------|
+| **异步架构** | 完全基于 async/await 的异步设计 |
+| **模块化系统** | 灵活的插件和模块管理 |
+| **热重载** | 开发时自动重载，无需重启 |
+| **错误管理** | 统一的错误处理和报告系统 |
+| **配置管理** | 灵活的配置存储和访问 |
 
-## 📦 安装
+---
 
-```bash
-pip install ErisPulse --upgrade
-```
+## 快速开始
+
+### 框架选型指南
+
+| 需求 | 推荐框架 | 理由 |
+|------|---------|------|
+| 轻量化/底层模块化 | [Framer](https://github.com/FramerOrg/Framer) | 高度解耦的模块化设计 |
+| 全功能机器人开发 | ErisPulse | 开箱即用的完整解决方案 |
 
 ---
 
-## 开发者快速入门
+## 安装指南
+
+我们全面采用 [`uv`](https://github.com/astral-sh/uv) 作为 Python 工具链，提供更快速可靠的安装体验。
+
+> ℹ️ **uv** 是由 Astral 开发的新一代 Python 包管理工具，比传统 pip 快 10-100 倍，并具有更好的依赖解析能力。
 
-ErisPulse SDK 支持使用 [`uv`](https://github.com/astral-sh/uv) 进行完整的开发环境管理。你可以**无需手动安装 Python**，直接通过 `uv` 下载 Python、创建虚拟环境并开始开发。
+### 1. 安装 uv
 
-### 安装 `uv`
+#### 通用方法 (pip):
+```bash
+pip install uv
+```
 
-#### macOS / Linux:
+#### macOS/Linux:
 ```bash
 curl -LsSf https://astral.sh/uv/install.sh | sh
 ```
@@ -95,11 +102,24 @@ curl -LsSf https://astral.sh/uv/install.sh | sh
 powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 ```
 
-验证是否安装成功：
+验证安装:
 ```bash
 uv --version
 ```
 
+### 2. 安装 ErisPulse
+
+```bash
+uv python install 3.12          # 安装 Python 3.12
+uv venv                         # 创建虚拟环境
+source .venv/bin/activate       # 激活环境 (Windows: .venv\Scripts\activate)
+uv pip install ErisPulse --upgrade  # 安装框架
+```
+
+---
+
+## 测试与开发
+
 ### 克隆项目并进入目录
 
 ```bash
@@ -107,18 +127,19 @@ git clone https://github.com/ErisPulse/ErisPulse.git
 cd ErisPulse
 ```
 
-### 使用 `uv` 自动下载 Python 并创建虚拟环境
+### 使用 `uv` 同步项目环境
 
 ```bash
-uv python install 3.12          # 自动下载并安装 Python 3.12
-uv venv                         # 创建默认 .venv 虚拟环境
-source .venv/bin/activate    
+uv sync
+
+# 启动虚拟环境
+source .venv/bin/activate   
 # Windows: .venv\Scripts\activate
 ```
 
-> ✅ 如果你切换分支或需要不同 Python 版本，只需替换 `3.12` 为其他版本即可。
+> `ErisPulse` 目前正在使用 `python3.13` 进行开发(所以您同步环境时会自动安装 `3.13`)，但也可以使用其他版本(版本不应低于 `3.10`)。
 
-### 安装依赖并开始开发
+### 安装依赖并开始
 
 ```bash
 uv pip install -e .
@@ -142,24 +163,36 @@ python -c "from ErisPulse import sdk; sdk.init()"
 uv run devs/test.py
 ```
 
-测试脚本提供以下功能：
-- 日志功能测试
-- 环境配置测试  
+测试功能包括:
+- 日志系统测试
+- 环境配置测试
 - 错误管理测试
 - 工具函数测试
 - 适配器功能测试
-- 版本信息查看
-
-### 开始开发
-
-你可以通过 CLI 工具进行模块调试、热重载开发等操作：
 
+### 开发模式 (热重载)
 ```bash
 epsdk run your_script.py --reload
 ```
 
 ---
 
-## 🤝 贡献
+## 🤝 贡献指南
+
+我们欢迎各种形式的贡献，包括但不限于:
+
+1. **报告问题**  
+   在 [GitHub Issues](https://github.com/ErisPulse/ErisPulse/issues) 提交bug报告
+
+2. **功能请求**  
+   通过 [社区讨论](https://github.com/ErisPulse/ErisPulse/discussions) 提出新想法
+
+3. **代码贡献**  
+   提交 Pull Request 前请阅读我们的 [开发指南](docs/DEVELOPMENT.md)
+
+4. **文档改进**  
+   帮助完善文档和示例代码
+
+---
 
-欢迎任何形式的贡献！无论是报告 bug、提出新功能请求，还是直接提交代码，都非常感谢。
+[加入社区讨论 →](https://github.com/ErisPulse/ErisPulse/discussions)

erispulse-1.1.16.dist-info/RECORD

@@ -0,0 +1,13 @@
+ErisPulse/__init__.py,sha256=FZUyXv8ZCO-xKzemSgp0Rw_snH_6BwI5i0F4sJu-5fs,8841
+ErisPulse/__main__.py,sha256=D718GwmJh9u1ce7u3f8wCxjB-VznwaWL_awSeHufq9M,52870
+ErisPulse/adapter.py,sha256=rrBdPSHvOzzN0VJCD8lThygM9I-_iQIeZ5iMgqCJ34w,13977
+ErisPulse/db.py,sha256=4qYFyOmgp_04xnrlO2Htyr5z6cjh6LtFyJa3zz0oTLw,24173
+ErisPulse/logger.py,sha256=UfQBF9fLx4WKe_se_lB5jNvaeTDtpv5PKT9x49QMmyw,8152
+ErisPulse/mods.py,sha256=1vEFiuL61Ouu7cocyysev5k2lGqcJ_hJGZqXNNbhJqg,9936
+ErisPulse/raiserr.py,sha256=QeKffL8Gm4Vl1DDMFQiKluiKCx0mxgN2Jj98WP4tUHo,3958
+ErisPulse/util.py,sha256=tmmZA4Ef5ElB01KZg2fTZLrkZOJbORjnkAd8sXj7xqw,4335
+erispulse-1.1.16.dist-info/METADATA,sha256=pqBRSDlkJUlODhMbKZEqEGs5Uvn_vvsIMwglS5l90_s,6371
+erispulse-1.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-1.1.16.dist-info/entry_points.txt,sha256=y8ppdsQhk-azC7_ikQgRr4rITSZ4VC4crVKtzHh4TBY,146
+erispulse-1.1.16.dist-info/licenses/LICENSE,sha256=plj4EYVfKAzc0ZWoC5T2vsQ86u0yLpu17NdAPeIcgVo,1066
+erispulse-1.1.16.dist-info/RECORD,,

erispulse-1.1.15.dist-info/RECORD

@@ -1,13 +0,0 @@
-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,,