ErisPulse 1.2.8__py3-none-any.whl → 2.1.0__py3-none-any.whl

ErisPulse/{logger.py → Core/logger.py}

@@ -1,120 +1,3 @@
-"""
-# 日志系统
-
-提供模块化、多级别的日志记录功能，支持内存存储和文件输出。实现了模块级别的日志控制、彩色输出和灵活的存储选项。
-
-## API 文档
-
-### 基本日志操作
-
-以debug为例：
-> 此外，还有其他级别的日志记录函数，如info, warning, error, critical等，用法相同。
-
-debug(msg: str, *args: Any, **kwargs: Any) -> None
-
-记录调试级别的日志信息。
-- 参数:
-  - msg: 日志消息
-  - *args: 传递给底层logger的位置参数
-  - **kwargs: 传递给底层logger的关键字参数
-- 返回:
-  - None
-- 示例:
-
-```python
-sdk.logger.debug("这是一条日志")
-```
-
-### 日志级别控制
-#### set_level(level: str) -> None
-设置全局日志级别。
-- 参数:
-  - level: 日志级别，可选值为 "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-- 返回:
-  - None
-- 示例:
-```python
-# 设置为调试级别
-sdk.logger.set_level("DEBUG")
-
-# 设置为生产环境级别
-sdk.logger.set_level("INFO")
-
-# 根据环境设置日志级别
-if is_production():
-    sdk.logger.set_level("WARNING")
-else:
-    sdk.logger.set_level("DEBUG")
-```
-
-#### set_module_level(module_name: str, level: str) -> bool
-设置特定模块的日志级别。
-- 参数:
-  - module_name: 模块名称
-  - level: 日志级别，可选值为 "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
-- 返回:
-  - bool: 设置是否成功
-- 示例:
-```python
-# 为特定模块设置详细日志
-sdk.logger.set_module_level("NetworkModule", "DEBUG")
-
-# 为敏感模块设置更高级别
-sdk.logger.set_module_level("AuthModule", "WARNING")
-
-# 根据配置设置模块日志级别
-for module, level in config.get("logging", {}).items():
-    success = sdk.logger.set_module_level(module, level)
-    if not success:
-        print(f"无法为模块 {module} 设置日志级别 {level}")
-```
-
-### 日志存储和输出
-#### set_output_file(path: Union[str, List[str]]) -> None
-设置日志输出文件。
-- 参数:
-  - path: 日志文件路径，可以是单个字符串或路径列表
-- 返回:
-  - None
-- 异常:
-  - 如果无法设置日志文件，会抛出异常
-- 示例:
-```python
-# 设置单个日志文件
-sdk.logger.set_output_file("app.log")
-
-# 设置多个日志文件
-sdk.logger.set_output_file(["app.log", "debug.log"])
-
-# 使用日期命名日志文件
-from datetime import datetime
-log_file = f"logs/app_{datetime.now().strftime('%Y%m%d')}.log"
-sdk.logger.set_output_file(log_file)
-```
-
-#### save_logs(path: Union[str, List[str]]) -> None
-保存内存中的日志到文件。
-- 参数:
-  - path: 保存路径，可以是单个字符串或路径列表
-- 返回:
-  - None
-- 异常:
-  - 如果无法保存日志，会抛出异常
-- 示例:
-```python
-# 保存到单个文件
-sdk.logger.save_logs("saved_logs.txt")
-
-# 保存到多个文件
-sdk.logger.save_logs(["main_log.txt", "backup_log.txt"])
-
-# 在应用退出前保存日志
-import atexit
-atexit.register(lambda: sdk.logger.save_logs("final_logs.txt"))
-```
-
-"""
-
 import logging
 import inspect
 import datetime
@@ -144,7 +27,7 @@ class Logger:
             return False
 
     def set_module_level(self, module_name: str, level: str) -> bool:
-        from .db import env
+        from .env import env
         if not env.get_module_status(module_name):
             self._logger.warning(f"模块 {module_name} 未启用，无法设置日志等级。")
             return False

ErisPulse/Core/mods.py

@@ -0,0 +1,226 @@
+"""
+ErisPulse 模块管理器
+
+提供模块的注册、状态管理和依赖关系处理功能。支持模块的启用/禁用、版本控制和依赖解析。
+
+{!--< tips >!--}
+1. 使用模块前缀区分不同模块的配置
+2. 支持模块状态持久化存储
+3. 自动处理模块间的依赖关系
+{!--< /tips >!--}
+"""
+
+import json
+from typing import Dict, Optional, Any, List, Set, Tuple, Union, Type, FrozenSet
+
+class ModuleManager:
+    """
+    模块管理器
+    
+    管理所有模块的注册、状态和依赖关系
+    
+    {!--< tips >!--}
+    1. 通过set_module/get_module管理模块信息
+    2. 通过set_module_status/get_module_status控制模块状态
+    3. 通过set_all_modules/get_all_modules批量操作模块
+    {!--< /tips >!--}
+    """
+    
+    DEFAULT_MODULE_PREFIX = "erispulse.module.data:"
+    DEFAULT_STATUS_PREFIX = "erispulse.module.status:"
+
+    def __init__(self):
+        from .env import env
+        self.env = env
+        self._ensure_prefixes()
+
+    def _ensure_prefixes(self) -> None:
+        """
+        {!--< internal-use >!--}
+        确保模块前缀配置存在
+        """
+        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: 模块数据前缀字符串
+        """
+        return self.env.get("erispulse.system.module_prefix")
+
+    @property
+    def status_prefix(self) -> str:
+        """
+        获取模块状态前缀
+        
+        :return: 模块状态前缀字符串
+        """
+        return self.env.get("erispulse.system.status_prefix")
+
+    def set_module_status(self, module_name: str, status: bool) -> None:
+        """
+        设置模块启用状态
+        
+        :param module_name: 模块名称
+        :param status: 启用状态
+        
+        :example:
+        >>> # 启用模块
+        >>> mods.set_module_status("MyModule", True)
+        >>> # 禁用模块
+        >>> mods.set_module_status("MyModule", False)
+        """
+        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:
+        """
+        获取模块启用状态
+        
+        :param module_name: 模块名称
+        :return: 模块是否启用
+        
+        :example:
+        >>> if mods.get_module_status("MyModule"):
+        >>>     print("模块已启用")
+        """
+        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[str, Any]) -> None:
+        """
+        设置模块信息
+        
+        :param module_name: 模块名称
+        :param module_info: 模块信息字典
+        
+        :example:
+        >>> mods.set_module("MyModule", {
+        >>>     "version": "1.0.0",
+        >>>     "description": "我的模块",
+        >>>     "status": True
+        >>> })
+        """
+        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[str, Any]]:
+        """
+        获取模块信息
+        
+        :param module_name: 模块名称
+        :return: 模块信息字典或None
+        
+        :example:
+        >>> module_info = mods.get_module("MyModule")
+        >>> if module_info:
+        >>>     print(f"模块版本: {module_info.get('version')}")
+        """
+        return self.env.get(f"{self.module_prefix}{module_name}")
+
+    def set_all_modules(self, modules_info: Dict[str, Dict[str, Any]]) -> None:
+        """
+        批量设置多个模块信息
+        
+        :param modules_info: 模块信息字典
+        
+        :example:
+        >>> mods.set_all_modules({
+        >>>     "Module1": {"version": "1.0", "status": True},
+        >>>     "Module2": {"version": "2.0", "status": False}
+        >>> })
+        """
+        for module_name, module_info in modules_info.items():
+            self.set_module(module_name, module_info)
+
+    def get_all_modules(self) -> Dict[str, Dict[str, Any]]:
+        """
+        获取所有模块信息
+        
+        :return: 模块信息字典
+        
+        :example:
+        >>> all_modules = mods.get_all_modules()
+        >>> for name, info in all_modules.items():
+        >>>     print(f"{name}: {info.get('status')}")
+        """
+        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[str, Any]) -> None:
+        """
+        更新模块信息
+        
+        :param module_name: 模块名称
+        :param module_info: 完整的模块信息字典
+        """
+        self.set_module(module_name, module_info)
+
+    def remove_module(self, module_name: str) -> bool:
+        """
+        移除模块
+        
+        :param module_name: 模块名称
+        :return: 是否成功移除
+        
+        :example:
+        >>> if mods.remove_module("OldModule"):
+        >>>     print("模块已移除")
+        """
+        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: Optional[str] = None, status_prefix: Optional[str] = None) -> None:
+        """
+        更新模块前缀配置
+        
+        :param module_prefix: 新的模块数据前缀(可选)
+        :param status_prefix: 新的模块状态前缀(可选)
+        
+        :example:
+        >>> # 更新模块前缀
+        >>> mods.update_prefixes(
+        >>>     module_prefix="custom.module.data:",
+        >>>     status_prefix="custom.module.status:"
+        >>> )
+        """
+        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/Core/raiserr.py

@@ -0,0 +1,152 @@
+"""
+ErisPulse 错误管理系统
+
+提供错误类型注册、抛出和管理功能，集成全局异常处理。支持自定义错误类型、错误链追踪和全局异常捕获。
+
+{!--< tips >!--}
+1. 使用register注册自定义错误类型
+2. 通过info获取错误信息
+3. 自动捕获未处理异常
+{!--< /tips >!--}
+"""
+
+import sys
+import traceback
+import asyncio
+from typing import Dict, Any, Optional, Type, Callable, List, Set, Tuple, Union
+
+class Error:
+    """
+    错误管理器
+    
+    提供错误类型注册和抛出功能
+    
+    {!--< tips >!--}
+    1. 通过register方法注册自定义错误类型
+    2. 通过动态属性访问抛出错误
+    3. 通过info方法获取错误信息
+    {!--< /tips >!--}
+    """
+    
+    def __init__(self):
+        self._types = {}
+
+    def register(self, name: str, doc: str = "", base: Type[Exception] = Exception) -> Type[Exception]:
+        """
+        注册新的错误类型
+        
+        :param name: 错误类型名称
+        :param doc: 错误描述文档
+        :param base: 基础异常类
+        :return: 注册的错误类
+        
+        :example:
+        >>> # 注册简单错误
+        >>> raiserr.register("SimpleError", "简单的错误类型")
+        >>> # 注册自定义基类的错误
+        >>> raiserr.register("AdvancedError", "高级错误", CustomBaseError)
+        """
+        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: str) -> Callable[..., None]:
+        """
+        动态获取错误抛出函数
+        
+        :param name: 错误类型名称
+        :return: 错误抛出函数
+        
+        :raises AttributeError: 当错误类型未注册时抛出
+        """
+        def raiser(msg: str, exit: bool = False) -> None:
+            """
+            错误抛出函数
+            
+            :param msg: 错误消息
+            :param exit: 是否退出程序
+            """
+            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: Optional[str] = None) -> Dict[str, Any]:
+        """
+        获取错误信息
+        
+        :param name: 错误类型名称(可选)
+        :return: 错误信息字典
+        
+        :example:
+        >>> # 获取特定错误信息
+        >>> error_info = raiserr.info("SimpleError")
+        >>> # 获取所有错误信息
+        >>> all_errors = raiserr.info()
+        """
+        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: Type[Exception], exc_value: Exception, exc_traceback: Any) -> None:
+    """
+    {!--< internal-use >!--}
+    全局异常处理器
+    
+    :param exc_type: 异常类型
+    :param exc_value: 异常值
+    :param 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: asyncio.AbstractEventLoop, context: Dict[str, Any]) -> None:
+    """
+    {!--< internal-use >!--}
+    异步异常处理器
+    
+    :param loop: 事件循环
+    :param 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)