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

ErisPulse/{envManager.py → db.py}

@@ -1,227 +1,227 @@
-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)
-            cls._instance.dev_mode = kwargs.get('dev_mode', False)
-        return cls._instance
-
-    def __init__(self, dev_mode=False):
-        if not hasattr(self, "_initialized"):
-            self.dev_mode = dev_mode
-            self._init_db()
-    
-    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
-        )
-        """)
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS modules (
-            module_name TEXT PRIMARY KEY,
-            status INTEGER NOT NULL,
-            version TEXT,
-            description TEXT,
-            author TEXT,
-            dependencies TEXT,
-            optional_dependencies TEXT,
-            pip_dependencies TEXT
-        )
-        """)
-        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 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 set_module_status(self, module_name, status):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-            UPDATE modules SET status = ? WHERE module_name = ?
-            """, (int(status), module_name))
-            conn.commit()
-    
-    def get_module_status(self, module_name):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-            SELECT status FROM modules WHERE module_name = ?
-            """, (module_name,))
-            result = cursor.fetchone()
-            return bool(result[0]) if result else True
-
-    def set_all_modules(self, modules_info):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            for module_name, module_info in modules_info.items():
-                meta = module_info.get('info', {}).get('meta', {})
-                dependencies = module_info.get('info', {}).get('dependencies', {})
-                cursor.execute("""
-                INSERT OR REPLACE INTO modules (
-                    module_name, status, version, description, author, 
-                    dependencies, optional_dependencies, pip_dependencies
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """, (
-                    module_name,
-                    int(module_info.get('status', True)),
-                    meta.get('version', ''),
-                    meta.get('description', ''),
-                    meta.get('author', ''),
-                    json.dumps(dependencies.get('requires', [])),
-                    json.dumps(dependencies.get('optional', [])),
-                    json.dumps(dependencies.get('pip', []))
-                ))
-            conn.commit()
-
-    def get_all_modules(self):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM modules")
-            rows = cursor.fetchall()
-            modules_info = {}
-            for row in rows:
-                module_name, status, version, description, author, dependencies, optional_dependencies, pip_dependencies = row
-                modules_info[module_name] = {
-                    'status': bool(status),
-                    'info': {
-                        'meta': {
-                            'version': version,
-                            'description': description,
-                            'author': author,
-                            'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []
-                        },
-                        'dependencies': {
-                            'requires': json.loads(dependencies) if dependencies else [],
-                            'optional': json.loads(optional_dependencies) if optional_dependencies else [],
-                            'pip': json.loads(pip_dependencies) if pip_dependencies else []
-                        }
-                    }
-                }
-            return modules_info
-
-    def set_module(self, module_name, module_info):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            meta = module_info.get('info', {}).get('meta', {})
-            dependencies = module_info.get('info', {}).get('dependencies', {})
-            cursor.execute("""
-            INSERT OR REPLACE INTO modules (
-                module_name, status, version, description, author, 
-                dependencies, optional_dependencies, pip_dependencies
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                module_name,
-                int(module_info.get('status', True)),
-                meta.get('version', ''),
-                meta.get('description', ''),
-                meta.get('author', ''),
-                json.dumps(dependencies.get('requires', [])),
-                json.dumps(dependencies.get('optional', [])),
-                json.dumps(dependencies.get('pip', []))
-            ))
-            conn.commit()
-
-    def get_module(self, module_name):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM modules WHERE module_name = ?", (module_name,))
-            row = cursor.fetchone()
-            if row:
-                module_name, status, version, description, author, dependencies, optional_dependencies, pip_dependencies = row
-                return {
-                    'status': bool(status),
-                    'info': {
-                        'meta': {
-                            'version': version,
-                            'description': description,
-                            'author': author,
-                            'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []
-                        },
-                        'dependencies': {
-                            'requires': json.loads(dependencies) if dependencies else [],
-                            'optional': json.loads(optional_dependencies) if optional_dependencies else [],
-                            'pip': json.loads(pip_dependencies) if pip_dependencies else []
-                        }
-                    }
-                }
-            return None
-
-    def update_module(self, module_name, module_info):
-        self.set_module(module_name, module_info)
-
-    def remove_module(self, module_name):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("DELETE FROM modules WHERE module_name = ?", (module_name,))
-            conn.commit()
-            return cursor.rowcount > 0
-    
-    def __getattr__(self, key):
-        try:
-            return self.get(key)
-        except KeyError:
-            raise AttributeError(f"配置项 {key} 不存在")
-
-env = EnvManager()
+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)
+            cls._instance.dev_mode = kwargs.get('dev_mode', False)
+        return cls._instance
+
+    def __init__(self, dev_mode=False):
+        if not hasattr(self, "_initialized"):
+            self.dev_mode = dev_mode
+            self._init_db()
+    
+    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
+        )
+        """)
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS modules (
+            module_name TEXT PRIMARY KEY,
+            status INTEGER NOT NULL,
+            version TEXT,
+            description TEXT,
+            author TEXT,
+            dependencies TEXT,
+            optional_dependencies TEXT,
+            pip_dependencies TEXT
+        )
+        """)
+        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 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 set_module_status(self, module_name, status):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+            UPDATE modules SET status = ? WHERE module_name = ?
+            """, (int(status), module_name))
+            conn.commit()
+    
+    def get_module_status(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+            SELECT status FROM modules WHERE module_name = ?
+            """, (module_name,))
+            result = cursor.fetchone()
+            return bool(result[0]) if result else True
+
+    def set_all_modules(self, modules_info):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            for module_name, module_info in modules_info.items():
+                meta = module_info.get('info', {}).get('meta', {})
+                dependencies = module_info.get('info', {}).get('dependencies', {})
+                cursor.execute("""
+                INSERT OR REPLACE INTO modules (
+                    module_name, status, version, description, author, 
+                    dependencies, optional_dependencies, pip_dependencies
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    module_name,
+                    int(module_info.get('status', True)),
+                    meta.get('version', ''),
+                    meta.get('description', ''),
+                    meta.get('author', ''),
+                    json.dumps(dependencies.get('requires', [])),
+                    json.dumps(dependencies.get('optional', [])),
+                    json.dumps(dependencies.get('pip', []))
+                ))
+            conn.commit()
+
+    def get_all_modules(self):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM modules")
+            rows = cursor.fetchall()
+            modules_info = {}
+            for row in rows:
+                module_name, status, version, description, author, dependencies, optional_dependencies, pip_dependencies = row
+                modules_info[module_name] = {
+                    'status': bool(status),
+                    'info': {
+                        'meta': {
+                            'version': version,
+                            'description': description,
+                            'author': author,
+                            'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []
+                        },
+                        'dependencies': {
+                            'requires': json.loads(dependencies) if dependencies else [],
+                            'optional': json.loads(optional_dependencies) if optional_dependencies else [],
+                            'pip': json.loads(pip_dependencies) if pip_dependencies else []
+                        }
+                    }
+                }
+            return modules_info
+
+    def set_module(self, module_name, module_info):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            meta = module_info.get('info', {}).get('meta', {})
+            dependencies = module_info.get('info', {}).get('dependencies', {})
+            cursor.execute("""
+            INSERT OR REPLACE INTO modules (
+                module_name, status, version, description, author, 
+                dependencies, optional_dependencies, pip_dependencies
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                module_name,
+                int(module_info.get('status', True)),
+                meta.get('version', ''),
+                meta.get('description', ''),
+                meta.get('author', ''),
+                json.dumps(dependencies.get('requires', [])),
+                json.dumps(dependencies.get('optional', [])),
+                json.dumps(dependencies.get('pip', []))
+            ))
+            conn.commit()
+
+    def get_module(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM modules WHERE module_name = ?", (module_name,))
+            row = cursor.fetchone()
+            if row:
+                module_name, status, version, description, author, dependencies, optional_dependencies, pip_dependencies = row
+                return {
+                    'status': bool(status),
+                    'info': {
+                        'meta': {
+                            'version': version,
+                            'description': description,
+                            'author': author,
+                            'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []
+                        },
+                        'dependencies': {
+                            'requires': json.loads(dependencies) if dependencies else [],
+                            'optional': json.loads(optional_dependencies) if optional_dependencies else [],
+                            'pip': json.loads(pip_dependencies) if pip_dependencies else []
+                        }
+                    }
+                }
+            return None
+
+    def update_module(self, module_name, module_info):
+        self.set_module(module_name, module_info)
+
+    def remove_module(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM modules WHERE module_name = ?", (module_name,))
+            conn.commit()
+            return cursor.rowcount > 0
+    
+    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()