ErisPulse 1.2.9__py3-none-any.whl → 2.1.1__py3-none-any.whl

ErisPulse/mods.py

@@ -1,345 +0,0 @@
-"""
-# 模块管理系统
-
-提供模块的注册、状态管理和依赖解析功能。支持模块信息存储、状态切换和批量操作。
-
-## API 文档
-
-### 模块状态管理
-#### set_module_status(module_name: str, status: bool) -> None
-设置模块的启用状态。
-- 参数:
-  - module_name: 模块名称
-  - status: 模块状态，True为启用，False为禁用
-- 返回:
-  - None
-- 示例:
-```python
-# 启用模块
-sdk.mods.set_module_status("MyModule", True)
-
-# 禁用模块
-sdk.mods.set_module_status("MyModule", False)
-
-# 条件性启用模块
-if check_dependencies():
-    sdk.mods.set_module_status("MyModule", True)
-else:
-    sdk.logger.warning("依赖检查失败，模块未启用")
-```
-
-#### get_module_status(module_name: str) -> bool
-获取模块的启用状态。
-- 参数:
-  - module_name: 模块名称
-- 返回:
-  - bool: 模块状态，True为启用，False为禁用
-- 示例:
-```python
-# 检查模块是否启用
-if sdk.mods.get_module_status("MyModule"):
-    print("模块已启用")
-else:
-    print("模块已禁用")
-    
-# 在条件中使用
-if sdk.mods.get_module_status("DatabaseModule") and sdk.mods.get_module_status("NetworkModule"):
-    start_application()
-```
-
-### 模块信息管理
-#### set_module(module_name: str, module_info: dict) -> None
-设置模块信息。
-- 参数:
-  - module_name: 模块名称
-  - module_info: 模块信息字典，包含模块的元数据和配置
-- 返回:
-  - None
-- 示例:
-```python
-# 设置基本模块信息
-sdk.mods.set_module("MyModule", {
-    "status": True,
-    "info": {
-        "meta": {
-            "name": "MyModule",
-            "version": "1.0.0",
-            "description": "示例模块",
-            "author": "开发者"
-        },
-        "dependencies": {
-            "requires": ["CoreModule"],
-            "optional": ["OptionalModule"],
-            "pip": ["requests", "numpy"]
-        }
-    }
-})
-
-# 更新现有模块信息
-module_info = sdk.mods.get_module("MyModule")
-module_info["info"]["meta"]["version"] = "1.1.0"
-sdk.mods.set_module("MyModule", module_info)
-```
-
-#### get_module(module_name: str) -> dict
-获取模块信息。
-- 参数:
-  - module_name: 模块名称
-- 返回:
-  - dict: 模块信息字典
-  - None: 如果模块不存在
-- 示例:
-```python
-# 获取模块信息
-module_info = sdk.mods.get_module("MyModule")
-if module_info:
-    print(f"模块版本: {module_info['info']['meta']['version']}")
-    print(f"模块描述: {module_info['info']['meta']['description']}")
-    print(f"模块状态: {'启用' if module_info['status'] else '禁用'}")
-else:
-    print("模块不存在")
-```
-
-#### get_all_modules() -> dict
-获取所有模块信息。
-- 参数: 无
-- 返回:
-  - dict: 包含所有模块信息的字典，键为模块名，值为模块信息
-- 示例:
-```python
-# 获取所有模块
-all_modules = sdk.mods.get_all_modules()
-
-# 统计启用和禁用的模块
-enabled_count = 0
-disabled_count = 0
-for name, info in all_modules.items():
-    if info.get("status", False):
-        enabled_count += 1
-    else:
-        disabled_count += 1
-        
-print(f"已启用模块: {enabled_count}")
-print(f"已禁用模块: {disabled_count}")
-
-# 查找特定类型的模块
-adapters = [name for name, info in all_modules.items() 
-           if "adapter" in info.get("info", {}).get("meta", {}).get("tags", [])]
-print(f"适配器模块: {adapters}")
-```
-
-#### update_module(module_name: str, module_info: dict) -> None
-更新模块信息。
-- 参数:
-  - module_name: 模块名称
-  - module_info: 更新后的模块信息字典
-- 返回:
-  - None
-- 示例:
-```python
-# 更新模块版本
-module_info = sdk.mods.get_module("MyModule")
-module_info["info"]["meta"]["version"] = "1.2.0"
-sdk.mods.update_module("MyModule", module_info)
-
-# 添加新的配置项
-module_info = sdk.mods.get_module("MyModule")
-if "config" not in module_info:
-    module_info["config"] = {}
-module_info["config"]["debug_mode"] = True
-sdk.mods.update_module("MyModule", module_info)
-```
-
-#### remove_module(module_name: str) -> bool
-删除模块。
-- 参数:
-  - module_name: 模块名称
-- 返回:
-  - bool: 是否成功删除
-- 示例:
-```python
-# 删除模块
-if sdk.mods.remove_module("OldModule"):
-    print("模块已成功删除")
-else:
-    print("模块不存在或删除失败")
-    
-# 条件删除
-if sdk.mods.get_module_status("TestModule") and is_test_environment():
-    sdk.mods.remove_module("TestModule")
-    print("测试模块已在生产环境中移除")
-```
-
-#### set_all_modules(modules_info: Dict[str, dict]) -> None
-批量设置多个模块信息。
-- 参数:
-  - modules_info: 模块信息字典的字典，键为模块名，值为模块信息
-- 返回:
-  - None
-- 示例:
-```python
-# 批量设置模块
-sdk.mods.set_all_modules({
-    "Module1": {
-        "status": True,
-        "info": {"meta": {"name": "Module1", "version": "1.0.0"}}
-    },
-    "Module2": {
-        "status": True,
-        "info": {"meta": {"name": "Module2", "version": "1.0.0"}}
-    }
-})
-
-# 从配置文件加载模块信息
-import json
-with open("modules_config.json", "r") as f:
-    modules_config = json.load(f)
-sdk.mods.set_all_modules(modules_config)
-```
-
-### 前缀管理
-#### update_prefixes(module_prefix: str = None, status_prefix: str = None) -> None
-更新存储前缀。
-- 参数:
-  - module_prefix: 模块存储前缀
-  - status_prefix: 状态存储前缀
-- 返回:
-  - None
-- 示例:
-```python
-# 更新模块前缀
-sdk.mods.update_prefixes(module_prefix="custom.module.")
-
-# 更新状态前缀
-sdk.mods.update_prefixes(status_prefix="custom.status.")
-
-# 同时更新两个前缀
-sdk.mods.update_prefixes(
-    module_prefix="app.modules.",
-    status_prefix="app.status."
-)
-```
-
-#### module_prefix 属性
-获取当前模块存储前缀。
-- 返回:
-  - str: 当前模块存储前缀
-- 示例:
-```python
-# 获取当前模块前缀
-prefix = sdk.mods.module_prefix
-print(f"当前模块前缀: {prefix}")
-
-# 在自定义存储操作中使用
-custom_key = f"{sdk.mods.module_prefix}custom.{module_name}"
-sdk.env.set(custom_key, custom_data)
-```
-
-#### status_prefix 属性
-获取当前状态存储前缀。
-- 返回:
-  - str: 当前状态存储前缀
-- 示例:
-```python
-# 获取当前状态前缀
-prefix = sdk.mods.status_prefix
-print(f"当前状态前缀: {prefix}")
-
-# 在自定义状态操作中使用
-custom_status_key = f"{sdk.mods.status_prefix}custom.{module_name}"
-sdk.env.set(custom_status_key, is_active)
-```
-
-"""
-
-import json
-from typing import Dict, Optional, Any, List, Set, Tuple, Union, Type, FrozenSet
-
-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))
-
-        module_info = self.get_module(module_name)
-        if module_info:
-            module_info["status"] = bool(status)
-            self.env.set(f"{self.module_prefix}{module_name}", module_info)
-
-    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

@@ -1,141 +0,0 @@
-"""
-# 错误管理系统
-
-提供错误类型注册、抛出和管理功能，集成全局异常处理。支持自定义错误类型、错误链追踪和全局异常捕获。
-
-## API 文档
-
-### 错误注册
-#### register(name: str, doc: str = "", base: type = Exception) -> type
-注册新的错误类型。
-- 参数:
-  - name: 错误类型名称
-  - doc: 错误描述文档
-  - base: 基础异常类，默认为Exception
-- 返回:
-  - type: 注册的错误类型类
-- 示例:
-```python
-# 注册一个简单错误
-sdk.raiserr.register("SimpleError", "简单的错误类型")
-
-# 注册带有自定义基类的错误
-class CustomBase(Exception):
-    pass
-sdk.raiserr.register("AdvancedError", "高级错误", CustomBase)
-```
-
-#### info(name: str = None) -> Dict[str, Any] or None
-获取错误类型信息。
-- 参数:
-  - name: 错误类型名称，如果为None则返回所有错误类型信息
-- 返回:
-  - Dict[str, Any]: 包含错误类型信息的字典，包括类型名、文档和类引用
-  - None: 如果指定的错误类型不存在
-- 示例:
-```python
-# 获取特定错误信息
-error_info = sdk.raiserr.info("SimpleError")
-print(f"错误类型: {error_info['type']}")
-print(f"错误描述: {error_info['doc']}")
-
-# 获取所有注册的错误信息
-all_errors = sdk.raiserr.info()
-for name, info in all_errors.items():
-    print(f"{name}: {info['doc']}")
-```
-
-### 错误抛出
-#### ErrorType(msg: str, exit: bool = False)
-动态生成的错误抛出函数。
-- 参数:
-  - msg: 错误消息
-  - exit: 是否在抛出错误后退出程序
-- 示例:
-```python
-# 抛出不退出的错误
-sdk.raiserr.SimpleError("操作失败")
-
-# 抛出导致程序退出的错误
-sdk.raiserr.CriticalError("致命错误", exit=True)
-
-# 带有异常捕获的使用方式
-try:
-    sdk.raiserr.ValidationError("数据验证失败")
-except Exception as e:
-    print(f"捕获到错误: {e}")
-```
-
-"""
-
-import sys
-import traceback
-import asyncio
-from typing import Dict, Any, Optional, Type, List, Set, Tuple, Union
-
-class Error:
-    def __init__(self):
-        self._types = {}
-
-    def register(self, name, doc="", base=Exception) -> Type:
-        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)
-
-            red = '\033[91m'
-            reset = '\033[0m'
-
-            logger.error(f"{red}{name}: {msg} | {err_cls.__doc__}{reset}")
-            logger.error(f"{red}{ ''.join(traceback.format_stack()) }{reset}")
-
-            if exit:
-                raise exc
-        return raiser
-
-    def info(self, name: str = None) -> Dict[str, Any]:
-        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 {
-                "type": None,
-                "doc": None,
-                "class": None,
-            }
-        return {
-            "type": name,
-            "doc": getattr(err_cls, "__doc__", ""),
-            "class": err_cls,
-        }
-
-raiserr = Error()
-
-# 全局异常处理器
-def global_exception_handler(exc_type, exc_value, exc_traceback):
-    error_message = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
-    raiserr.ExternalError(
-        f"{exc_type.__name__}: {exc_value}\nTraceback:\n{error_message}"
-    )
-def async_exception_handler(loop, context):
-    exception = context.get('exception')
-    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/util.py

@@ -1,144 +0,0 @@
-"""
-# 工具函数集合
-
-提供各种实用工具函数和装饰器，简化开发流程。
-
-## API 文档
-### 拓扑排序：
-    - topological_sort(elements: List[str], dependencies: Dict[str, List[str]], error: Type[Exception]) -> List[str]: 拓扑排序依赖关系
-    - show_topology() -> str: 可视化模块依赖关系
-
-### 装饰器：
-    - @cache: 缓存函数结果
-    - @run_in_executor: 将同步函数转为异步
-    - @retry(max_attempts=3, delay=1): 失败自动重试
-
-### 异步执行：
-    - ExecAsync(async_func: Callable, *args: Any, **kwargs: Any) -> Any: 异步执行函数
-
-### 示例用法：
-
-```
-from ErisPulse import sdk
-
-# 拓扑排序
-sorted_modules = sdk.util.topological_sort(modules, dependencies, error)
-
-# 缓存装饰器
-@sdk.util.cache
-def expensive_operation(param):
-    return heavy_computation(param)
-    
-# 异步执行
-@sdk.util.run_in_executor
-def sync_task():
-    pass
-    
-# 重试机制
-@sdk.util.retry(max_attempts=3, delay=1)
-def unreliable_operation():
-    pass
-```
-
-"""
-
-import time
-import asyncio
-import functools
-import traceback
-from concurrent.futures import ThreadPoolExecutor
-from collections import defaultdict, deque
-from typing import List, Dict, Type, Callable, Any, Optional, Set
-
-executor = ThreadPoolExecutor()
-
-def topological_sort(elements, dependencies, error) -> List[str]:
-    graph = defaultdict(list)
-    in_degree = {element: 0 for element in elements}
-    for element, deps in dependencies.items():
-        for dep in deps:
-            graph[dep].append(element)
-            in_degree[element] += 1
-    queue = deque([element for element in elements if in_degree[element] == 0])
-    sorted_list = []
-    while queue:
-        node = queue.popleft()
-        sorted_list.append(node)
-        for neighbor in graph[node]:
-            in_degree[neighbor] -= 1
-            if in_degree[neighbor] == 0:
-                queue.append(neighbor)
-    if len(sorted_list) != len(elements):
-        from . import sdk
-        sdk.logger.error(f"依赖导入错误: {elements} vs  {sorted_list} | 发生了循环依赖")
-    return sorted_list
-
-def show_topology() -> str:
-    from . import sdk
-    dep_data = sdk.env.get('module_dependencies')
-    if not dep_data:
-        return "未找到模块依赖关系数据，请先运行sdk.init()"
-        
-    sorted_modules = topological_sort(
-        dep_data['modules'], 
-        dep_data['dependencies'], 
-        sdk.raiserr.CycleDependencyError
-    )
-    
-    tree = {}
-    for module in sorted_modules:
-        tree[module] = dep_data['dependencies'].get(module, [])
-    
-    result = ["模块拓扑关系表:"]
-    for i, module in enumerate(sorted_modules, 1):
-        deps = dep_data['dependencies'].get(module, [])
-        indent = "  " * (len(deps) if deps else 0)
-        result.append(f"{i}. {indent}{module}")
-        if deps:
-            result.append(f"   {indent}└─ 依赖: {', '.join(deps)}")
-    
-    return "\n".join(result)
-
-def ExecAsync(async_func, *args, **kwargs) -> Any:
-    loop = asyncio.get_event_loop()
-    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()
-        try:
-            return await loop.run_in_executor(None, lambda: func(*args, **kwargs))
-        except Exception as e:
-            from . import sdk
-            sdk.logger.error(f"线程内发生未处理异常:\n{''.join(traceback.format_exc())}")
-            sdk.raiserr.CaughtExternalError(
-                f"检测到线程内异常，请优先使用 sdk.raiserr 抛出错误。\n原始异常: {type(e).__name__}: {e}"
-            )
-    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.2.9.dist-info/RECORD

@@ -1,13 +0,0 @@
-ErisPulse/__init__.py,sha256=2hEVWxKaDfFGAe3ekpUFx5tIub2riwDtSscsfpA0T2w,11108
-ErisPulse/__main__.py,sha256=MQ_npNFErw5m8My092apQ4gyZAL-7VPLL9Wc7HTq4f4,56451
-ErisPulse/adapter.py,sha256=sho8HMYVSa3syovU2mDxV2Wsw99yD5_sFz6UER89Tes,14367
-ErisPulse/db.py,sha256=mSLLxjqOxSwvMbBSYCpH9TvCvdfccWrKJx6GtkhAl8U,23881
-ErisPulse/logger.py,sha256=ftXp4bfk0S5cnkK4wmF5WqhvuzpUL4MXsuJa-ZTBoMs,8760
-ErisPulse/mods.py,sha256=2OgueJPetQ5N1uDr5DiFvDZ4zF1HSuZ4OsL8IFDqro8,9976
-ErisPulse/raiserr.py,sha256=vUhJKrxwAf7ituacOZv2z2YeY4xxfMG-oLHXiDCHrBs,4176
-ErisPulse/util.py,sha256=eXtmW39bCjbV8lxOmOro4b4gyBhKo-db_EeffJ9BDf0,4525
-erispulse-1.2.9.dist-info/METADATA,sha256=Qf5mU81APxguKIJ36OPN8EJN45a6ofw-Gc3F2zgCLvE,6696
-erispulse-1.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-1.2.9.dist-info/entry_points.txt,sha256=y8ppdsQhk-azC7_ikQgRr4rITSZ4VC4crVKtzHh4TBY,146
-erispulse-1.2.9.dist-info/licenses/LICENSE,sha256=qAe8UGD2uYa8mUPqffBkdIS_4Q5d66FlhYuo3eC_Dq8,1396
-erispulse-1.2.9.dist-info/RECORD,,