ErisPulse 1.0.13__py3-none-any.whl → 1.0.14__py3-none-any.whl

ErisPulse/db.py

@@ -0,0 +1,97 @@
+import os
+import json
+import sqlite3
+import importlib.util
+from pathlib import Path
+
+class EnvManager:
+    _instance = None
+    db_path = os.path.join(os.path.dirname(__file__), "config.db")
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, "_initialized"):
+            self._init_db()
+            self._initialized = True
+    
+    def _init_db(self):
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS config (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def get(self, key, default=None):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT value FROM config WHERE key = ?", (key,))
+                result = cursor.fetchone()
+            if result:
+                try:
+                    return json.loads(result[0])
+                except json.JSONDecodeError:
+                    return result[0]
+            return default
+        except sqlite3.OperationalError as e:
+            if "no such table" in str(e):
+                self._init_db()
+                return self.get(key, default)
+            else:
+                raise
+    
+    def get_all_keys(self) -> list:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT key FROM config")
+            return [row[0] for row in cursor.fetchall()]
+    
+    def set(self, key, value):
+        serialized_value = json.dumps(value) if isinstance(value, (dict, list)) else str(value)
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)", (key, serialized_value))
+        conn.commit()
+        conn.close()
+
+    def delete(self, key):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM config WHERE key = ?", (key,))
+        conn.commit()
+        conn.close()
+    
+    def clear(self):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM config")
+        conn.commit()
+        conn.close()
+
+    def load_env_file(self):
+        env_file = Path("env.py")
+        if env_file.exists():
+            spec = importlib.util.spec_from_file_location("env_module", env_file)
+            env_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(env_module)
+            for key, value in vars(env_module).items():
+                if not key.startswith("__") and isinstance(value, (dict, list, str, int, float, bool)):
+                    self.set(key, value)
+    
+    def __getattr__(self, key):
+        try:
+            return self.get(key)
+        except KeyError:
+            raise AttributeError(f"配置项 {key} 不存在")
+
+env = EnvManager()

ErisPulse/logger.py

@@ -1,48 +1,152 @@
-import logging
-import inspect
-from .envManager import env
-
-_logger = logging.getLogger("RyhBot")
-_log_level = env.get("LOG_LEVEL", "DEBUG")
-if _log_level is None:
-    _log_level = logging.DEBUG
-_logger.setLevel(_log_level)
-
-if not _logger.handlers:
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter("%(message)s"))
-    _logger.addHandler(console_handler)
-
-def _get_caller():
-    frame = inspect.currentframe().f_back.f_back
-    module = inspect.getmodule(frame)
-    module_name = module.__name__
-    if module_name == "__main__":
-        module_name = "Main"
-    if module_name.endswith(".Core"):
-        module_name = module_name[:-5]
-    return module_name
-
-def debug(msg, *args, **kwargs):
-    caller_module = _get_caller()
-    _logger.debug(f"[{caller_module}] {msg}", *args, **kwargs)
-
-
-def info(msg, *args, **kwargs):
-    caller_module = _get_caller()
-    _logger.info(f"[{caller_module}] {msg}", *args, **kwargs)
-
-
-def warning(msg, *args, **kwargs):
-    caller_module = _get_caller()
-    _logger.warning(f"[{caller_module}] {msg}", *args, **kwargs)
-
-
-def error(msg, *args, **kwargs):
-    caller_module = _get_caller()
-    _logger.error(f"[{caller_module}] {msg}", *args, **kwargs)
-
-
-def critical(msg, *args, **kwargs):
-    caller_module = _get_caller()
-    _logger.critical(f"[{caller_module}] {msg}", *args, **kwargs)
+import logging
+import inspect
+import datetime
+import functools
+
+class Logger:
+    def __init__(self):
+        self._logs = {}
+        self._module_levels = {}
+        self._logger = logging.getLogger("ErisPulse")
+        self._logger.setLevel(logging.DEBUG)
+        self._file_handler = None
+        if not self._logger.handlers:
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(logging.Formatter("%(message)s"))
+            self._logger.addHandler(console_handler)
+
+    def set_level(self, level: str):
+        level = level.upper()
+        if hasattr(logging, level):
+            self._logger.setLevel(getattr(logging, level))
+    
+    def set_module_level(self, module_name: str, level: str) -> bool:
+        from .db import env
+        if not env.get_module_status(module_name):
+            self._logger.warning(f"模块 {module_name} 未启用，无法设置日志等级。")
+            return False
+        level = level.upper()
+        if hasattr(logging, level):
+            self._module_levels[module_name] = getattr(logging, level)
+            self._logger.info(f"模块 {module_name} 日志等级已设置为 {level}")
+            return True
+        else:
+            self._logger.error(f"无效的日志等级: {level}")
+            return False
+    
+    def set_output_file(self, path: str | list):
+        if self._file_handler:
+            self._logger.removeHandler(self._file_handler)
+            self._file_handler.close()
+        
+        if isinstance(path, str):
+            path = [path]
+        
+        for p in path:
+            try:
+                file_handler = logging.FileHandler(p, encoding='utf-8')
+                file_handler.setFormatter(logging.Formatter("%(message)s"))
+                self._logger.addHandler(file_handler)
+                self._logger.info(f"日志输出已设置到文件: {p}")
+            except Exception as e:
+                self._logger.error(f"无法设置日志文件 {p}: {e}")
+                raise e
+        
+    def save_logs(self, path: str | list):
+        if self._logs == None:
+            self._logger.warning("没有log记录可供保存。")
+            return
+        if isinstance(path, str):
+            path = [path]
+        
+        for p in path:
+            try:
+                with open(p, "w", encoding="utf-8") as file:
+                    for module, logs in self._logs.items():
+                        file.write(f"Module: {module}\n")
+                        for log in logs:
+                            file.write(f"  {log}\n")
+                    self._logger.info(f"日志已被保存到：{p}。")
+            except Exception as e:
+                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] = []
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        msg = f"{timestamp} - {msg}"
+        self._logs[ModuleName].append(msg)
+    
+    def _get_effective_level(self, module_name):
+        return self._module_levels.get(module_name, self._logger.level)
+    
+    def _get_caller(self):
+        frame = inspect.currentframe().f_back.f_back
+        module = inspect.getmodule(frame)
+        module_name = module.__name__
+        if module_name == "__main__":
+            module_name = "Main"
+        if module_name.endswith(".Core"):
+            module_name = module_name[:-5]
+        return module_name
+
+    def debug(self, msg, *args, **kwargs):
+        caller_module = self._get_caller()
+        if self._get_effective_level(caller_module) <= logging.DEBUG:
+            self._save_in_memory(caller_module, msg)
+            self._logger.debug(f"[{caller_module}] {msg}", *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        caller_module = self._get_caller()
+        if self._get_effective_level(caller_module) <= logging.INFO:
+            self._save_in_memory(caller_module, msg)
+            self._logger.info(f"[{caller_module}] {msg}", *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs):
+        caller_module = self._get_caller()
+        if self._get_effective_level(caller_module) <= logging.WARNING:
+            self._save_in_memory(caller_module, msg)
+            self._logger.warning(f"[{caller_module}] {msg}", *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        caller_module = self._get_caller()
+        if self._get_effective_level(caller_module) <= logging.ERROR:
+            self._save_in_memory(caller_module, msg)
+            self._logger.error(f"[{caller_module}] {msg}", *args, **kwargs)
+
+    def critical(self, msg, *args, **kwargs):
+        caller_module = self._get_caller()
+        if self._get_effective_level(caller_module) <= logging.CRITICAL:
+            self._save_in_memory(caller_module, msg)
+            self._logger.critical(f"[{caller_module}] {msg}", *args, **kwargs)
+
+logger = Logger()

ErisPulse/mods.py

@@ -0,0 +1,86 @@
+import json
+from typing import Dict, Optional
+
+class ModuleManager:
+    DEFAULT_MODULE_PREFIX = "erispulse.module.data:"
+    DEFAULT_STATUS_PREFIX = "erispulse.module.status:"
+    
+    def __init__(self):
+        from .db import env
+        self.env = env
+        self._ensure_prefixes()
+    
+    def _ensure_prefixes(self):
+        if not self.env.get("erispulse.system.module_prefix"):
+            self.env.set("erispulse.system.module_prefix", self.DEFAULT_MODULE_PREFIX)
+        if not self.env.get("erispulse.system.status_prefix"):
+            self.env.set("erispulse.system.status_prefix", self.DEFAULT_STATUS_PREFIX)
+    
+    @property
+    def module_prefix(self) -> str:
+        return self.env.get("erispulse.system.module_prefix")
+    
+    @property
+    def status_prefix(self) -> str:
+        return self.env.get("erispulse.system.status_prefix")
+
+    def set_module_status(self, module_name: str, status: bool) -> None:
+        self.env.set(f"{self.status_prefix}{module_name}", bool(status))
+    
+    def get_module_status(self, module_name: str) -> bool:
+        status = self.env.get(f"{self.status_prefix}{module_name}", True)
+        if isinstance(status, str):
+            return status.lower() == 'true'
+        return bool(status)
+
+    def set_module(self, module_name: str, module_info: dict) -> None:
+        self.env.set(f"{self.module_prefix}{module_name}", module_info)
+        self.set_module_status(module_name, module_info.get('status', True))
+
+    def get_module(self, module_name: str) -> Optional[dict]:
+        return self.env.get(f"{self.module_prefix}{module_name}")
+
+    def set_all_modules(self, modules_info: Dict[str, dict]) -> None:
+        for module_name, module_info in modules_info.items():
+            self.set_module(module_name, module_info)
+
+    def get_all_modules(self) -> dict:
+        modules_info = {}
+        all_keys = self.env.get_all_keys()
+        prefix_len = len(self.module_prefix)
+        
+        for key in all_keys:
+            if key.startswith(self.module_prefix):
+                module_name = key[prefix_len:]
+                module_info = self.get_module(module_name)
+                if module_info:
+                    status = self.get_module_status(module_name)
+                    module_info['status'] = bool(status)
+                    modules_info[module_name] = module_info
+        return modules_info
+    
+    def update_module(self, module_name: str, module_info: dict) -> None:
+        self.set_module(module_name, module_info)
+
+    def remove_module(self, module_name: str) -> bool:
+        module_key = f"{self.module_prefix}{module_name}"
+        status_key = f"{self.status_prefix}{module_name}"
+        
+        if self.env.get(module_key) is not None:
+            self.env.delete(module_key)
+            self.env.delete(status_key)
+            return True
+        return False
+
+    def update_prefixes(self, module_prefix: str = None, status_prefix: str = None) -> None:
+        if module_prefix:
+            if not module_prefix.endswith(':'):
+                module_prefix += ':'
+            self.env.set("erispulse.system.module_prefix", module_prefix)
+        
+        if status_prefix:
+            if not status_prefix.endswith(':'):
+                status_prefix += ':'
+            self.env.set("erispulse.system.status_prefix", status_prefix)
+
+mods = ModuleManager()

ErisPulse/raiserr.py

@@ -0,0 +1,44 @@
+import sys
+import traceback
+
+class Error:
+    def __init__(self):
+        self._types = {}
+
+    def register(self, name, doc="", base=Exception):
+        if name not in self._types:
+            err_cls = type(name, (base,), {"__doc__": doc})
+            self._types[name] = err_cls
+        return self._types[name]
+
+    def __getattr__(self, name):
+        def raiser(msg, exit=False):
+            from .logger import logger
+            err_cls = self._types.get(name) or self.register(name)
+            exc = err_cls(msg)
+            logger.error(f"{name}: {msg} | {err_cls.__doc__}")
+            logger.error("".join(traceback.format_stack()))
+            if exit:
+                raise exc
+        return raiser
+
+    def info(self, name: str = None):
+        result = {}
+        for err_name, err_cls in self._types.items():
+            result[err_name] = {
+                "type": err_name,
+                "doc": getattr(err_cls, "__doc__", ""),
+                "class": err_cls,
+            }
+        if name is None:
+            return result
+        err_cls = self._types.get(name)
+        if not err_cls:
+            return None
+        return {
+            "type": name,
+            "doc": getattr(err_cls, "__doc__", ""),
+            "class": err_cls,
+        }
+    
+raiserr = Error()

ErisPulse/util.py

@@ -1,8 +1,8 @@
-from collections import defaultdict, deque
+import time
 import asyncio
-import os
-import shutil
+import functools
 from concurrent.futures import ThreadPoolExecutor
+from collections import defaultdict, deque
 
 executor = ThreadPoolExecutor()
 
@@ -28,4 +28,37 @@ def topological_sort(elements, dependencies, error):
 
 def ExecAsync(async_func, *args, **kwargs):
     loop = asyncio.get_event_loop()
-    return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))
+    return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))
+
+def cache(func):
+    cache_dict = {}
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        key = (args, tuple(sorted(kwargs.items())))
+        if key not in cache_dict:
+            cache_dict[key] = func(*args, **kwargs)
+        return cache_dict[key]
+    return wrapper
+
+def run_in_executor(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, lambda: func(*args, **kwargs))
+    return wrapper
+
+def retry(max_attempts=3, delay=1):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < max_attempts:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    attempts += 1
+                    if attempts == max_attempts:
+                        raise
+                    time.sleep(delay)
+        return wrapper
+    return decorator

{erispulse-1.0.13.dist-info → erispulse-1.0.14.dist-info}/METADATA

@@ -1,96 +1,73 @@
-Metadata-Version: 2.4
-Name: ErisPulse
-Version: 1.0.13
-Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
-Home-page: https://github.com/wsu2059q/ErisPulse
-Author: 艾莉丝·格雷拉特(WSu2059)
-Author-email: wsu2059@qq.com
-Maintainer: runoneall
-Maintainer-email: runoobsteve@gmail.com
-License: MIT
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-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: Programming Language :: Python :: 3 :: Only
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: aiohttp
-Requires-Dist: rich
-Requires-Dist: prompt_toolkit
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: maintainer
-Dynamic: maintainer-email
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# 🚀 ErisPulse - 异步机器人开发框架
-
-基于 [RyhBotPythonSDK V2](https://github.com/runoneall/RyhBotPythonSDK2) 构建，由 [sdkFrame](https://github.com/runoneall/sdkFrame) 提供支持的异步机器人开发框架。
-
-## ✨ 核心特性
-- 完全异步架构设计
-- 模块化插件系统
-- 多协议支持
-- 模块热更新
-- 跨平台兼容
-
-## 📦 安装
-
-```bash
-pip install ErisPulse --upgrade
-```
-
-**系统要求**：
-- Python ≥ 3.7
-- pip ≥ 20.0
-
-## 🚀 快速开始
-
-```python
-import asyncio
-from ErisPulse import sdk, logger
-
-async def main():
-    sdk.init()
-    logger.info("ErisPulse 已启动")
-    # 这里可以添加自定义逻辑 | 如模块的 AddHandle，AddTrigger 等
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## 🛠️ 常用命令
-
-```bash
-epsdk update                # 更新模块源
-epsdk install AIChat        # 安装模块
-epsdk enable AIChat         # 启用模块
-epsdk list                  # 查看所有模块
-```
-更多命令详见 [命令行工具文档](docs/CLI.md)。
-
-## 🧩 模块开发
-
-你可以通过实现自定义模块扩展 ErisPulse 功能。详见 [开发指南](docs/DEVELOPMENT.md)。
-
-## 📖 文档导航
-- [开发指南](docs/DEVELOPMENT.md) - 完整的开发文档
-- [命令行工具](docs/CLI.md) - CLI 使用手册
-- [源配置指南](docs/ORIGIN.md) - 模块源配置说明
-- [更新日志](docs/CHANGELOG.md) - 版本更新历史
+Metadata-Version: 2.4
+Name: ErisPulse
+Version: 1.0.14
+Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>, runoneall <runoobsteve@gmail.com>
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp
+
+⚠ 当前版本处于开发中，请谨慎使用。
+
+![](./.github/assets/erispulse_logo.png)
+
+基于 [RyhBotPythonSDK V2](https://github.com/runoneall/RyhBotPythonSDK2) 构建，由 [sdkFrame](https://github.com/runoneall/sdkFrame) 提供支持的异步机器人开发框架。
+
+## ✨ 核心特性
+- ⚡ 完全异步架构设计（async/await）
+- 🧩 模块化插件系统
+- 📜 内置日志系统
+- 🛑 统一的错误管理
+- 🛠️ 灵活的配置管理
+
+## 📦 安装
+
+```bash
+pip install ErisPulse --upgrade
+```
+
+**要求**：Python ≥ 3.7，pip ≥ 20.0
+
+## 🚀 快速开始
+
+```python
+import asyncio
+from ErisPulse import sdk, logger
+
+async def main():
+    sdk.init()
+    logger.info("ErisPulse 已启动")
+    # 这里可以添加自定义逻辑 | 如模块的 AddHandle，AddTrigger 等
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## 导航
+- [开发指南](docs/DEVELOPMENT.md) - 完整的开发文档
+- [命令行工具](docs/CLI.md) - CLI 使用手册
+- [源配置指南](docs/ORIGIN.md) - 模块源配置说明
+- [更新日志](docs/CHANGELOG.md) - 版本更新历史
+- [底层API](docs/REFERENCE.md) - 方法与接口
+- [GitHub Discussions](https://github.com/ErisPulse/ErisPulse/discussions)
+
+## 🤝 贡献
+
+欢迎任何形式的贡献！无论是报告 bug、提出新功能请求，还是直接提交代码，都非常感谢。
+
+## 📄 许可证
+
+本项目采用 [MIT 许可证](LICENSE)。

erispulse-1.0.14.dist-info/RECORD

@@ -0,0 +1,12 @@
+ErisPulse/__init__.py,sha256=eLYg5fmwxwXsH7YK7z2f5AZRZA5SQIoS0xqMJN7KhVg,6717
+ErisPulse/__main__.py,sha256=-UdhsYP_X7EagomCjo73Y_qQdXwtMbDS5KoOSrI-OcU,32181
+ErisPulse/db.py,sha256=CnREeykvRmEDx9HE4bS4gakcAUYWuBOfN3WgPsQMAd4,3208
+ErisPulse/logger.py,sha256=HwceD81nLiLCh_WGcCVsEG6OqL-NL5HmdONFTGH-8Og,6023
+ErisPulse/mods.py,sha256=o6yT5YhNyfeCpXrEFZYSBCr3YQqjFXZ0hN3u1XoKHJ4,3360
+ErisPulse/raiserr.py,sha256=WTMQEUbUSx4PS9_l9cEnuNuvm6zulgwQFipqVZZg3zc,1296
+ErisPulse/util.py,sha256=01kUQwVFeE7gyD1skCwjpANYzVUHjLC6J1UUzfQXPco,2139
+erispulse-1.0.14.dist-info/METADATA,sha256=ti21P0tgTbDVG25EHIJ-T1k17zKszLLvo3v_VVaOKUY,2497
+erispulse-1.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+erispulse-1.0.14.dist-info/entry_points.txt,sha256=AjKvOdYR7QGXVpEJhjUYUwV2JluE4lm9vNbknC3hjOM,155
+erispulse-1.0.14.dist-info/top_level.txt,sha256=Lm_qtkVvNJR8_dXh_qEDdl_12cZGpic-i4HUlVVUMZc,10
+erispulse-1.0.14.dist-info/RECORD,,

{erispulse-1.0.13.dist-info → erispulse-1.0.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any