ErisPulse 1.0.7__tar.gz

erispulse-1.0.7/ErisPulse/__init__.py

@@ -0,0 +1,135 @@
+import os
+import sys
+from . import sdk
+from . import util
+from . import errors
+from . import logger
+from .envManager import env
+
+setattr(sdk, "env", env)
+setattr(sdk, "logger", logger)
+setattr(sdk, "util", util)
+
+env.load_env_file()
+
+def init():
+    try:
+        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] = []
+
+        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:
+                    logger.warning(f"模块 {module_name} 的 'moduleInfo' 字典 缺少必要 'name' 键.")
+                    continue
+                if not hasattr(moduleObj, "Main"):
+                    logger.warning(f"模块 {module_name} 缺少 'Main' 类.")
+                    continue
+                
+                module_info = env.get_module(moduleObj.moduleInfo["name"])
+                if module_info is None:
+                    module_info = {
+                        "status": True,
+                        "info": moduleObj.moduleInfo
+                    }
+                    env.set_module(moduleObj.moduleInfo["name"], module_info)
+                    logger.info(f"模块 {moduleObj.moduleInfo['name']} 信息已初始化并存储到数据库")
+                
+                if not module_info.get('status', True):
+                    disabledModules.append(module_name)
+                    logger.warning(f"模块 {moduleObj.moduleInfo['name']} 已禁用，跳过加载")
+                    continue
+                    
+                required_deps = moduleObj.moduleInfo.get("dependencies", [])
+                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}")
+                    raise errors.MissingDependencyError(f"模块 {module_name} 缺少必需依赖: {missing_required_deps}")
+
+                optional_deps = moduleObj.moduleInfo.get("optional_dependencies", [])
+                available_optional_deps = []
+
+                for dep in optional_deps:
+                    if isinstance(dep, list):
+                        if all(d in TempModules for d in dep):
+                            available_optional_deps.extend(dep)
+                    elif dep in TempModules:
+                        available_optional_deps.append(dep)
+
+                if optional_deps and not available_optional_deps:
+                    logger.warning(f"模块 {module_name} 缺少所有可选依赖: {optional_deps}")
+                    continue
+
+                sdkInstalledModuleNames.append(module_name)
+            except Exception as e:
+                logger.warning(f"模块 {module_name} 加载失败: {e}")
+                continue
+
+        sdkModuleDependencies = {}
+        for module_name in sdkInstalledModuleNames:
+            moduleObj = __import__(module_name)
+            moduleDependecies: list[str] = moduleObj.moduleInfo.get("dependencies", [])
+
+            optional_deps = moduleObj.moduleInfo.get("optional_dependencies", [])
+            available_optional_deps = [dep for dep in optional_deps if dep in sdkInstalledModuleNames]
+            moduleDependecies.extend(available_optional_deps)
+
+            for dep in moduleDependecies:
+                if dep in disabledModules:
+                    logger.warning(f"模块 {module_name} 的依赖模块 {dep} 已禁用，跳过加载")
+                    continue
+            
+            if not all(dep in sdkInstalledModuleNames for dep in moduleDependecies):
+                raise errors.InvalidDependencyError(
+                    f"模块 {module_name} 的依赖无效: {moduleDependecies}"
+                )
+            sdkModuleDependencies[module_name] = moduleDependecies
+
+        sdkInstalledModuleNames: list[str] = sdk.util.topological_sort(
+            sdkInstalledModuleNames, sdkModuleDependencies, errors.CycleDependencyError
+        )
+
+        all_modules_info = {}
+        for module_name in sdkInstalledModuleNames:
+            moduleObj = __import__(module_name)
+            moduleInfo: dict = moduleObj.moduleInfo
+
+            module_info = env.get_module(moduleInfo["name"])
+            env.set_module(moduleInfo["name"], {
+                "status": True,
+                "info": moduleInfo
+            })
+        logger.debug("所有模块信息已加载并存储到数据库")
+
+        for module_name in sdkInstalledModuleNames:
+            moduleObj = __import__(module_name)
+            moduleInfo = moduleObj.moduleInfo
+            module_status = env.get_module_status(moduleInfo["name"])
+            if not module_status:
+                continue
+            
+            moduleMain = moduleObj.Main(sdk, logger)
+            setattr(moduleMain, "moduleInfo", moduleInfo)
+            setattr(sdk, moduleInfo["name"], moduleMain)
+            logger.debug(f"模块 {moduleInfo['name']} 正在初始化")
+    except Exception as e:
+        logger.error(f"初始化失败: {e}")
+        raise e
+
+sdk.init = init

erispulse-1.0.7/ErisPulse/__main__.py

@@ -0,0 +1,464 @@
+import argparse
+import os
+import sys
+import shutil
+import aiohttp
+import zipfile
+import asyncio
+import subprocess
+import json
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from .envManager import env
+from .origin import origin_manager
+
+console = Console()
+
+def enable_module(module_name):
+    module_info = env.get_module(module_name)
+    if module_info:
+        env.set_module_status(module_name, True)
+        console.print(f"[green]模块 {module_name} 已启用[/green]")
+    else:
+        console.print(f"[red]模块 {module_name} 不存在[/red]")
+
+def disable_module(module_name):
+    module_info = env.get_module(module_name)
+    if module_info:
+        env.set_module_status(module_name, False)
+        console.print(f"[yellow]模块 {module_name} 已禁用[/yellow]")
+    else:
+        console.print(f"[red]模块 {module_name} 不存在[/red]")
+
+async def fetch_url(session, url):
+    try:
+        async with session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()
+    except Exception as e:
+        console.print(f"[red]请求失败: {e}[/red]")
+        return None
+
+def extract_and_setup_module(module_name, module_url, zip_path, module_dir):
+    try:
+        console.print(f"[cyan]正在从 {module_url} 下载模块...[/cyan]")
+        
+        async def download_module():
+            async with aiohttp.ClientSession() as session:
+                content = await fetch_url(session, module_url)
+                if content is None:
+                    return False
+                
+                with open(zip_path, 'wb') as zip_file:
+                    zip_file.write(content)
+
+                if not os.path.exists(module_dir):
+                    os.makedirs(module_dir)
+
+                with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                    zip_ref.extractall(module_dir)
+                
+                init_file_path = os.path.join(module_dir, '__init__.py')
+                if not os.path.exists(init_file_path):
+                    sub_module_dir = os.path.join(module_dir, module_name)
+                    m_sub_module_dir = os.path.join(module_dir, f"m_{module_name}")
+                    for sub_dir in [sub_module_dir, m_sub_module_dir]:
+                        if os.path.exists(sub_dir) and os.path.isdir(sub_dir):
+                            for item in os.listdir(sub_dir):
+                                source_item = os.path.join(sub_dir, item)
+                                target_item = os.path.join(module_dir, item)
+                                if os.path.exists(target_item):
+                                    os.remove(target_item)
+                                shutil.move(source_item, module_dir)
+                            os.rmdir(sub_dir)
+
+                console.print(f"[green]模块 {module_name} 文件已成功解压并设置[/green]")
+                return True
+        
+        return asyncio.run(download_module())
+
+    except Exception as e:
+        console.print(Panel(f"[red]处理模块 {module_name} 文件失败: {e}[/red]", title="错误", border_style="red"))
+        if os.path.exists(zip_path):
+            try:
+                os.remove(zip_path)
+            except Exception as cleanup_error:
+                console.print(f"[red]清理失败: {cleanup_error}[/red]")
+        return False
+
+    finally:
+        if os.path.exists(zip_path):
+            try:
+                os.remove(zip_path)
+            except Exception as cleanup_error:
+                console.print(f"[red]清理失败: {cleanup_error}[/red]")
+
+def install_pip_dependencies(dependencies):
+    if not dependencies:
+        return True
+
+    console.print("[cyan]正在安装pip依赖...[/cyan]")
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install"] + dependencies,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        console.print(result.stdout.decode())
+        return True
+    except subprocess.CalledProcessError as e:
+        console.print(Panel(f"[red]安装pip依赖失败: {e.stderr.decode()}[/red]", title="错误", border_style="red"))
+        return False
+
+def install_module(module_name, force=False):
+    module_info = env.get_module(module_name)
+    if module_info and not force:
+        console.print(f"[yellow]模块 {module_name} 已存在，使用 --force 参数强制重装[/yellow]")
+        return
+
+    providers = env.get('providers', {})
+    if isinstance(providers, str):
+        providers = json.loads(providers)
+
+    module_info = []
+    for provider, url in providers.items():
+        module_key = f"{module_name}@{provider}"
+        modules_data = env.get('modules', {})
+        if isinstance(modules_data, str):
+            modules_data = json.loads(modules_data)
+
+        if module_key in modules_data:
+            module_data = modules_data[module_key]
+            module_info.append({
+                'provider': provider,
+                'url': url,
+                'path': module_data.get('path', ''),
+                'version': module_data.get('version', '未知'),
+                'description': module_data.get('description', '无描述'),
+                'author': module_data.get('author', '未知'),
+                'dependencies': module_data.get('dependencies', []),
+                'optional_dependencies': module_data.get('optional_dependencies', []),
+                'pip_dependencies': module_data.get('pip_dependencies', [])
+            })
+
+    if not module_info:
+        console.print(f"[red]未找到模块 {module_name}[/red]")
+        return
+
+    if len(module_info) > 1:
+        console.print(f"[cyan]找到 {len(module_info)} 个源的 {module_name} 模块：[/cyan]")
+        table = Table(title="可选模块源", show_header=True, header_style="bold magenta")
+        table.add_column("编号", style="cyan")
+        table.add_column("源", style="green")
+        table.add_column("版本", style="blue")
+        table.add_column("描述", style="white")
+        table.add_column("作者", style="yellow")
+        for i, info in enumerate(module_info):
+            table.add_row(str(i+1), info['provider'], info['version'], info['description'], info['author'])
+        console.print(table)
+
+        while True:
+            choice = Prompt.ask("请选择要安装的源 (输入编号)", default="1")
+            if choice.isdigit() and 1 <= int(choice) <= len(module_info):
+                selected_module = module_info[int(choice)-1]
+                break
+            else:
+                console.print("[red]输入无效，请重新选择[/red]")
+    else:
+        selected_module = module_info[0]
+
+    for dep in selected_module['dependencies']:
+        console.print(f"[cyan]正在安装依赖模块 {dep}...[/cyan]")
+        install_module(dep)
+
+    third_party_deps = selected_module.get('pip_dependencies', [])
+    if third_party_deps:
+        console.print(f"[cyan]模块 {module_name} 需要以下pip依赖: {', '.join(third_party_deps)}[/cyan]")
+        if not install_pip_dependencies(third_party_deps):
+            console.print(f"[red]无法安装模块 {module_name} 的pip依赖，安装终止[/red]")
+            return
+    
+    module_url = selected_module['url'] + selected_module['path']
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    module_dir = os.path.join(script_dir, 'modules', module_name)
+    zip_path = os.path.join(script_dir, f"{module_name}.zip")
+
+    if not extract_and_setup_module(
+        module_name=module_name,
+        module_url=module_url,
+        zip_path=zip_path,
+        module_dir=module_dir
+    ):
+        return
+
+    env.set_module(module_name, {
+        'status': True,
+        'info': {
+            'version': selected_module['version'],
+            'description': selected_module['description'],
+            'author': selected_module['author'],
+            'dependencies': selected_module['dependencies'],
+            'optional_dependencies': selected_module['optional_dependencies'],
+            'pip_dependencies': selected_module['pip_dependencies']
+        }
+    })
+    console.print(f"[green]模块 {module_name} 安装成功[/green]")
+
+def uninstall_module(module_name):
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    module_path = os.path.join(script_dir, 'modules', module_name)
+
+    module_file_path = module_path + '.py'
+    if os.path.exists(module_file_path):
+        try:
+            os.remove(module_file_path)
+        except Exception as e:
+            console.print(f"[red]删除模块文件 {module_name} 时出错: {e}[/red]")
+    elif os.path.exists(module_path) and os.path.isdir(module_path):
+        try:
+            shutil.rmtree(module_path)
+        except Exception as e:
+            console.print(f"[red]删除模块目录 {module_name} 时出错: {e}[/red]")
+    else:
+        console.print(f"[red]模块 {module_name} 不存在[/red]")
+        return
+    
+    module_info = env.get_module(module_name)
+    if not module_info:
+        console.print(f"[red]模块 {module_name} 不存在[/red]")
+        return
+    
+    pip_dependencies = module_info.get('info', {}).get('pip_dependencies', [])
+    if pip_dependencies:
+        all_modules = env.get_all_modules()
+        unused_pip_dependencies = []
+        
+        essential_packages = {'aiohttp', 'rich'}
+
+        for dep in pip_dependencies:
+            if dep in essential_packages:
+                console.print(f"[yellow]跳过必要模块 {dep} 的卸载[/yellow]")
+                continue
+
+            is_dependency_used = False
+            for name, info in all_modules.items():
+                if name != module_name and dep in info.get('info', {}).get('pip_dependencies', []):
+                    is_dependency_used = True
+                    break
+            if not is_dependency_used:
+                unused_pip_dependencies.append(dep)
+        
+        if unused_pip_dependencies:
+            console.print(f"[cyan]以下 pip 依赖不再被其他模块使用: {', '.join(unused_pip_dependencies)}[/cyan]")
+            confirm = Confirm.ask("[yellow]是否卸载这些 pip 依赖？[/yellow]", default=False)
+            if confirm:
+                console.print(f"[cyan]正在卸载 pip 依赖: {', '.join(unused_pip_dependencies)}[/cyan]")
+                try:
+                    subprocess.run(
+                        [sys.executable, "-m", "pip", "uninstall", "-y"] + unused_pip_dependencies,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE
+                    )
+                    console.print(f"[green]成功卸载 pip 依赖: {', '.join(unused_pip_dependencies)}[/green]")
+                except subprocess.CalledProcessError as e:
+                    console.print(Panel(f"[red]卸载 pip 依赖失败: {e.stderr.decode()}[/red]", title="错误", border_style="red"))
+    
+    if env.remove_module(module_name):
+        console.print(f"[green]模块 {module_name} 已删除[/green]")
+    else:
+        console.print(f"[red]模块 {module_name} 不存在[/red]")
+def upgrade_all_modules(force=False):
+    all_modules = env.get_all_modules()
+    if not all_modules:
+        console.print("[yellow]未找到任何模块，无法更新[/yellow]")
+        return
+
+    providers = env.get('providers', {})
+    if isinstance(providers, str):
+        providers = json.loads(providers)
+
+    modules_data = env.get('modules', {})
+    if isinstance(modules_data, str):
+        modules_data = json.loads(modules_data)
+
+    updates_available = []
+    for module_name, module_info in all_modules.items():
+        local_version = module_info['info'].get('version', '0.0.0')
+        for provider, url in providers.items():
+            module_key = f"{module_name}@{provider}"
+            if module_key in modules_data:
+                remote_module = modules_data[module_key]
+                remote_version = remote_module.get('version', '0.0.0')
+                if remote_version > local_version:
+                    updates_available.append({
+                        'name': module_name,
+                        'local_version': local_version,
+                        'remote_version': remote_version,
+                        'provider': provider,
+                        'url': url,
+                        'path': remote_module.get('path', ''),
+                    })
+
+    if not updates_available:
+        console.print("[green]所有模块已是最新版本，无需更新[/green]")
+        return
+
+    console.print("\n[cyan]以下模块有可用更新：[/cyan]")
+    table = Table(title="可用更新", show_header=True, header_style="bold magenta")
+    table.add_column("模块", style="cyan")
+    table.add_column("当前版本", style="yellow")
+    table.add_column("最新版本", style="green")
+    table.add_column("源", style="blue")
+    for update in updates_available:
+        table.add_row(update['name'], update['local_version'], update['remote_version'], update['provider'])
+    console.print(table)
+
+    if not force:
+        confirm = Confirm.ask("[yellow]警告：更新模块可能会导致兼容性问题，请在更新前查看插件作者的相关声明。\n是否继续？[/yellow]", default=False)
+        if not confirm:
+            console.print("[yellow]更新已取消[/yellow]")
+            return
+
+    for update in updates_available:
+        console.print(f"[cyan]正在更新模块 {update['name']}...[/cyan]")
+        module_url = update['url'] + update['path']
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        module_dir = os.path.join(script_dir, 'modules', update['name'])
+        zip_path = os.path.join(script_dir, f"{update['name']}.zip")
+
+        if not extract_and_setup_module(
+            module_name=update['name'],
+            module_url=module_url,
+            zip_path=zip_path,
+            module_dir=module_dir
+        ):
+            continue
+
+        all_modules[update['name']]['info']['version'] = update['remote_version']
+        env.set_all_modules(all_modules)
+        console.print(f"[green]模块 {update['name']} 已更新至版本 {update['remote_version']}[/green]")
+
+def list_modules(module_name=None):
+    all_modules = env.get_all_modules()
+    if not all_modules:
+        console.print("[yellow]未在数据库中发现注册模块,正在初始化模块列表...[/yellow]")
+        from . import init as init_module
+        init_module()
+        all_modules = env.get_all_modules()
+
+    if not all_modules:
+        console.print("[red]未找到任何模块[/red]")
+        return
+
+    table = Table(title="模块列表", show_header=True, header_style="bold magenta")
+    table.add_column("模块名称", style="cyan")
+    table.add_column("状态", style="green")
+    table.add_column("版本", style="blue")
+    table.add_column("描述", style="white")
+    table.add_column("依赖", style="yellow")
+    table.add_column("可选依赖", style="magenta")
+    table.add_column("pip依赖", style="cyan")
+
+    for name, info in all_modules.items():
+        status = "启用" if info.get("status", True) else "禁用"
+        dependencies = ', '.join(info['info'].get('dependencies', [])) if info['info'].get('dependencies') else '无'
+        optional_dependencies = ', '.join(info['info'].get('optional_dependencies', [])) if info['info'].get('optional_dependencies') else '无'
+        pip_dependencies = ', '.join(info['info'].get('pip_dependencies', [])) if info['info'].get('pip_dependencies') else '无'
+        table.add_row(
+            name,
+            status,
+            info['info'].get('version', '未知'),
+            info['info'].get('description', '无描述'),
+            dependencies,
+            optional_dependencies,
+            pip_dependencies
+        )
+
+    console.print(table)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="ErisPulse 命令行工具",
+        prog="python -m ErisPulse"
+    )
+    subparsers = parser.add_subparsers(dest='command', help='可用命令')
+
+    enable_parser = subparsers.add_parser('enable', help='启用指定模块')
+    enable_parser.add_argument('module_name', type=str, help='要启用的模块名称')
+    enable_parser.add_argument('--init', action='store_true', help='在启用模块前初始化模块数据库')
+
+    disable_parser = subparsers.add_parser('disable', help='禁用指定模块')
+    disable_parser.add_argument('module_name', type=str, help='要禁用的模块名称')
+    disable_parser.add_argument('--init', action='store_true', help='在禁用模块前初始化模块数据库')
+
+    list_parser = subparsers.add_parser('list', help='列出所有模块信息')
+    list_parser.add_argument('--module', '-m', type=str, help='指定要展示的模块名称')
+
+    update_parser = subparsers.add_parser('update', help='更新模块列表')
+
+    upgrade_parser = subparsers.add_parser('upgrade', help='升级模块列表')
+    upgrade_parser.add_argument('--force', action='store_true', help='跳过二次确认，强制更新')
+
+    uninstall_parser = subparsers.add_parser('uninstall', help='删除指定模块')
+    uninstall_parser.add_argument('module_name', type=str, help='要删除的模块名称')
+
+    install_parser = subparsers.add_parser('install', help='安装指定模块（支持多个模块，用逗号分隔）')
+    install_parser.add_argument('module_name', type=str, help='要安装的模块名称')
+    install_parser.add_argument('--force', action='store_true', help='强制重新安装模块')
+    install_parser.add_argument('--init', action='store_true', help='在安装模块前初始化模块数据库')
+
+    origin_parser = subparsers.add_parser('origin', help='管理模块源')
+    origin_subparsers = origin_parser.add_subparsers(dest='origin_command', help='源管理命令')
+
+    add_origin_parser = origin_subparsers.add_parser('add', help='添加模块源')
+    add_origin_parser.add_argument('url', type=str, help='要添加的模块源URL')
+
+    list_origin_parser = origin_subparsers.add_parser('list', help='列出所有模块源')
+
+    del_origin_parser = origin_subparsers.add_parser('del', help='删除模块源')
+    del_origin_parser.add_argument('url', type=str, help='要删除的模块源URL')
+
+    args = parser.parse_args()
+
+    if hasattr(args, 'init') and args.init:
+        console.print("[yellow]正在初始化模块列表...[/yellow]")
+        from . import init as init_module
+        init_module()
+
+    # 全部指令：enable, disable, list, uninstall, install, update, origin(add, list, del)
+    if args.command == 'enable':
+        enable_module(args.module_name)
+    elif args.command == 'disable':
+        disable_module(args.module_name)
+    elif args.command == 'list':
+        list_modules(args.module)
+    elif args.command == 'uninstall':
+        uninstall_module(args.module_name)
+    elif args.command == 'install':
+        module_names = args.module_name.split(',')
+        for module_name in module_names:
+            module_name = module_name.strip()
+            if module_name:
+                install_module(module_name, args.force)
+    elif args.command == 'update':
+        origin_manager.update_origins()
+    elif args.command == 'upgrade':
+        upgrade_all_modules(args.force)
+    elif args.command == 'origin':
+        if args.origin_command == 'add':
+            origin_manager.add_origin(args.url)
+        elif args.origin_command == 'list':
+            origin_manager.list_origins()
+        elif args.origin_command == 'del':
+            origin_manager.del_origin(args.url)
+        else:
+            origin_parser.print_help()
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

erispulse-1.0.7/ErisPulse/envManager.py

@@ -0,0 +1,211 @@
+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()
+    
+    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():
+                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)),
+                    module_info.get('info', {}).get('version', ''),
+                    module_info.get('info', {}).get('description', ''),
+                    module_info.get('info', {}).get('author', ''),
+                    json.dumps(module_info.get('info', {}).get('dependencies', [])),
+                    json.dumps(module_info.get('info', {}).get('optional_dependencies', [])),
+                    json.dumps(module_info.get('info', {}).get('pip_dependencies', []))  # 新增
+                ))
+            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': {
+                        'version': version,
+                        'description': description,
+                        'author': author,
+                        'dependencies': json.loads(dependencies) if dependencies else [],
+                        'optional_dependencies': json.loads(optional_dependencies) if optional_dependencies else [],
+                        'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []  # 新增
+                    }
+                }
+            return modules_info
+
+    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': {
+                        'version': version,
+                        'description': description,
+                        'author': author,
+                        'dependencies': json.loads(dependencies) if dependencies else [],
+                        'optional_dependencies': json.loads(optional_dependencies) if optional_dependencies else [],
+                        'pip_dependencies': json.loads(pip_dependencies) if pip_dependencies else []  # 新增
+                    }
+                }
+            return None
+
+    def set_module(self, module_name, module_info):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            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)),
+                module_info.get('info', {}).get('version', ''),
+                module_info.get('info', {}).get('description', ''),
+                module_info.get('info', {}).get('author', ''),
+                json.dumps(module_info.get('info', {}).get('dependencies', [])),
+                json.dumps(module_info.get('info', {}).get('optional_dependencies', [])),
+                json.dumps(module_info.get('info', {}).get('pip_dependencies', []))  # 新增
+            ))
+            conn.commit()
+
+    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-1.0.7/ErisPulse/errors.py

@@ -0,0 +1,16 @@
+class CycleDependencyError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidDependencyError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidModuleError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

erispulse-1.0.7/ErisPulse/logger.py

@@ -0,0 +1,60 @@
+import logging
+import inspect
+from rich.logging import RichHandler
+from . import sdk
+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 = RichHandler(
+        show_time=True,                         # 显示时间
+        show_level=True,                        # 显示日志级别
+        show_path=False,                        # 不显示调用路径
+        markup=True,                            # 支持 Markdown
+        log_time_format="[%Y-%m-%d %H:%M:%S]",  # 自定义时间格式
+        rich_tracebacks=True,                   # 支持更美观的异常堆栈
+    )
+    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)

erispulse-1.0.7/ErisPulse/origin.py

@@ -0,0 +1,112 @@
+import asyncio
+import aiohttp
+from .envManager import env
+
+class OriginManager:
+    def __init__(self):
+        self._init_origins()
+
+    def _init_origins(self):
+        if not env.get('origins'):
+            env.set('origins', [])
+
+    async def _validate_url(self, url):
+        if not url.startswith(('http://', 'https://')):
+            protocol = input("未指定协议，请输入使用的协议 (http 或 https): ").strip().lower()
+            if protocol not in ['http', 'https']:
+                print("无效的协议类型，必须是 http 或 https。")
+                return None
+            url = f"{protocol}://{url}"
+        
+        if not url.endswith('.json'):
+            url = f"{url}/map.json"
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    response.raise_for_status()
+                    if response.headers.get('Content-Type', '').startswith('application/json'):
+                        return url
+                    else:
+                        print(f"源 {url} 返回的内容不是有效的 JSON 格式。")
+                        return None
+        except Exception as e:
+            print(f"访问源 {url} 失败: {e}")
+            return None
+
+
+    def add_origin(self, value):
+        validated_url = asyncio.run(self._validate_url(value))
+        if not validated_url:
+            print("提供的源不是一个有效源，请检查后重试。")
+            return
+
+        origins = env.get('origins')
+        if validated_url not in origins:
+            origins.append(validated_url)
+            env.set('origins', origins)
+            print(f"源 {validated_url} 已成功添加。")
+        else:
+            print(f"源 {validated_url} 已存在，无需重复添加。")
+
+    def update_origins(self):
+        origins = env.get('origins')
+        providers = {}
+        modules = {}
+        module_alias = {}
+        
+        print("\033[1m{:<10} | {:<20} | {:<50}\033[0m".format("源", "模块", "地址"))
+        print("-" * 85)
+
+        async def fetch_origin_data():
+            async with aiohttp.ClientSession() as session:
+                for origin in origins:
+                    print(f"\n\033[94m正在获取 {origin}\033[0m")
+                    try:
+                        async with session.get(origin) as response:
+                            response.raise_for_status()
+                            if response.headers.get('Content-Type', '').startswith('application/json'):
+                                content = await response.json()
+                                providers[content["name"]] = content["base"]
+                                
+                                for module in list(content["modules"].keys()):
+                                    module_content = content["modules"][module]
+                                    modules[f'{module}@{content["name"]}'] = module_content
+                                    module_origin_name = module_content["path"]
+                                    module_alias_name = module
+                                    module_alias[f'{module_origin_name}@{content["name"]}'] = module_alias_name
+
+                                    print("{:<10} | {:<20} | {:<50}".format(
+                                        content['name'], 
+                                        module, 
+                                        f"{providers[content['name']]}{module_origin_name}"
+                                    ))
+                            else:
+                                print(f"\033[91m源 {origin} 返回的内容不是有效的 JSON 格式。\033[0m")
+                    except Exception as e:
+                        print(f"\033[91m获取 {origin} 时出错: {e}\033[0m")
+
+        # 使用 asyncio.run 调用异步任务
+        asyncio.run(fetch_origin_data())
+
+        env.set('providers', providers)
+        env.set('modules', modules)
+        env.set('module_alias', module_alias)
+        
+        print("\n\033[92m{}\033[0m".format("完成".center(85, "-")))
+
+    def list_origins(self):
+        origins = env.get('origins')
+        for origin in origins:
+            print(origin)
+
+    def del_origin(self, value):
+        origins = env.get('origins')
+        if value in origins:
+            origins.remove(value)
+            env.set('origins', origins)
+            print(f"源 {value} 已删除。")
+        else:
+            print(f"源 {value} 不存在。")
+
+origin_manager = OriginManager()

erispulse-1.0.7/ErisPulse/sdk.py

@@ -0,0 +1,3 @@
+
+if __name__ == "__main__":
+    print("别删我哦 (｡•́︿•̀｡) ，我超级有用呢！")

erispulse-1.0.7/ErisPulse/util.py

@@ -0,0 +1,30 @@
+from collections import defaultdict, deque
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+executor = ThreadPoolExecutor()
+
+
+def topological_sort(elements, dependencies, error):
+    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):
+        raise error(f"Cycle detected in the dependencies: {elements} -> {dependencies}")
+    return sorted_list
+
+def ExecAsync(async_func, *args, **kwargs):
+    loop = asyncio.get_event_loop()
+    return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))

erispulse-1.0.7/ErisPulse.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: ErisPulse
+Version: 1.0.7
+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
+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) 提供支持。这是一个异步版本的 SDK，可能在功能和特性上与原库存在一定差异。
+
+ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+
+# 更新日志
+## 1.0.4
+修复了部分命令行不支持logger颜色代码的问题 | 替换为rich
+
+## 1.0.5
+更新了SDK 模块对于pip依赖安装的支持
+
+## 1.0.6
+修复了SDK-CLI中的颜色乱码问题,并将db调整为包内存储,以解决多进程问题
+
+## 1.0.7
+修复诸多小问题

erispulse-1.0.7/ErisPulse.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+ErisPulse/__init__.py
+ErisPulse/__main__.py
+ErisPulse/envManager.py
+ErisPulse/errors.py
+ErisPulse/logger.py
+ErisPulse/origin.py
+ErisPulse/sdk.py
+ErisPulse/util.py
+ErisPulse.egg-info/PKG-INFO
+ErisPulse.egg-info/SOURCES.txt
+ErisPulse.egg-info/dependency_links.txt
+ErisPulse.egg-info/requires.txt
+ErisPulse.egg-info/top_level.txt

erispulse-1.0.7/ErisPulse.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

erispulse-1.0.7/ErisPulse.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp
+rich

erispulse-1.0.7/ErisPulse.egg-info/top_level.txt

@@ -0,0 +1 @@
+ErisPulse

erispulse-1.0.7/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: ErisPulse
+Version: 1.0.7
+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
+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) 提供支持。这是一个异步版本的 SDK，可能在功能和特性上与原库存在一定差异。
+
+ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+
+# 更新日志
+## 1.0.4
+修复了部分命令行不支持logger颜色代码的问题 | 替换为rich
+
+## 1.0.5
+更新了SDK 模块对于pip依赖安装的支持
+
+## 1.0.6
+修复了SDK-CLI中的颜色乱码问题,并将db调整为包内存储,以解决多进程问题
+
+## 1.0.7
+修复诸多小问题

erispulse-1.0.7/README.md

@@ -0,0 +1,18 @@
+# ErisPulse
+
+本项目基于 [RyhBotPythonSDK V2](https://github.com/runoneall/RyhBotPythonSDK2) 构建，并由 [sdkFrame](https://github.com/runoneall/sdkFrame) 提供支持。这是一个异步版本的 SDK，可能在功能和特性上与原库存在一定差异。
+
+ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+
+# 更新日志
+## 1.0.4
+修复了部分命令行不支持logger颜色代码的问题 | 替换为rich
+
+## 1.0.5
+更新了SDK 模块对于pip依赖安装的支持
+
+## 1.0.6
+修复了SDK-CLI中的颜色乱码问题,并将db调整为包内存储,以解决多进程问题
+
+## 1.0.7
+修复诸多小问题

erispulse-1.0.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

erispulse-1.0.7/setup.py

@@ -0,0 +1,33 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='ErisPulse',
+    version='1.0.7',
+    author='艾莉丝·格雷拉特(WSu2059)',
+    author_email='wsu2059@qq.com',
+    maintainer='runoneall',
+    maintainer_email='runoobsteve@gmail.com',
+    description='ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。',
+    long_description=open('README.md', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/wsu2059q/ErisPulse',
+    packages=find_packages(),
+    install_requires=["aiohttp", "rich"],
+    license='MIT',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3 :: Only',  # 仅支持 Python 3
+        'Operating System :: OS Independent',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    python_requires='>=3.7',
+)