tretool 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

tretool/plugin.py

@@ -1,27 +1,52 @@
 """
 ### PyPlugin - Python 高级插件库
-##### 概述\n
+##### 概述
 PyPlugin 是一个功能强大的 Python 插件系统框架，提供了完整的插件开发、加载和执行解决方案。该系统特别适合构建可扩展的应用程序，支持：
 
 - 插件生命周期管理：自动处理插件的加载、验证和执行
-
 - 智能依赖检查：支持版本规范的依赖管理 (package>=1.2.0)
-
 - 元数据验证：自动检查插件元数据的完整性和合理性
-
 - 优先级系统：数值越小优先级越高(1-100范围)
-
 - 彩色终端输出：使用 Rich 库提供直观的状态反馈
+- 插件隔离：可选在独立进程中运行插件
+- 热重载支持：动态重新加载插件而不重启应用
+- 配置系统：支持插件级别的配置管理
 """
 
 import importlib
-
+import os
+import sys
+import inspect
+from collections import OrderedDict
+from pathlib import Path
+from multiprocessing import Process, Queue
+from typing import Type, List, Dict, Any, Optional, Union, Callable, Tuple
+from dataclasses import dataclass, field
 from abc import ABC, abstractmethod
-from typing import Type, List, Dict, Any, overload, Union
+from enum import Enum, auto
 
 from rich import print as rich_print
+from rich.table import Table
+from rich.panel import Panel
 from packaging.version import parse as parse_version
+import yaml
+
+
+class PluginState(Enum):
+    """插件状态枚举"""
+    UNLOADED = auto()
+    LOADED = auto()
+    INITIALIZED = auto()
+    READY = auto()
+    ERROR = auto()
+
 
+@dataclass
+class PluginConfig:
+    """插件配置数据类"""
+    enabled: bool = True
+    priority: Optional[int] = None
+    config: Dict[str, Any] = field(default_factory=dict)
 
 
 class PluginBase(ABC):
@@ -32,22 +57,28 @@ class PluginBase(ABC):
         "name": "Unnamed Plugin",
         "version": "1.0.0",
         "author": "Anonymous",
-        "description": "No description provided"
+        "description": "No description provided",
+        "category": "uncategorized"
     }
     
     # 定义插件依赖包（子类可覆盖）
     required_packages: List[str] = []
     
     # 默认执行优先级（数值越小优先级越高）
-    priority: int = 10
-
+    priority: int = 50
+    
+    # 是否在独立进程中运行
+    run_in_process: bool = False
+    
+    # 插件状态
+    _state: PluginState = PluginState.UNLOADED
     
-
     def __init__(self):
-        """初始化时自动检查依赖"""
+        """初始化时自动检查依赖和元数据"""
         self._check_metadata()
-
         self._check_dependencies()
+        self._state = PluginState.INITIALIZED
+        self._config = PluginConfig()
         
     def _check_dependencies(self):
         """验证依赖包是否已安装，并检查版本要求"""
@@ -55,89 +86,75 @@ class PluginBase(ABC):
         invalid = []
         version_issues = []
         
-        # 处理特殊的依赖格式 (如 "package>=1.0")
-        dependencies = []
         for dep in self.required_packages:
-            if isinstance(dep, str) and any(op in dep for op in [">", "<", "=", "!"]):
-                # 处理版本要求
-                try:
-                    pkg_name = dep.split('>')[0].split('<')[0].split('=')[0].split('!')[0].strip()
-                    dependencies.append((pkg_name, dep))
-                except Exception:
-                    dependencies.append((dep, None))
-            else:
-                dependencies.append((dep, None))
-        
-        for pkg, version_spec in dependencies:
             try:
+                # 处理版本规范
+                if any(op in dep for op in [">", "<", "=", "!"]):
+                    pkg_name = dep.split('>')[0].split('<')[0].split('=')[0].split('!')[0].strip()
+                    version_spec = dep[len(pkg_name):].strip()
+                else:
+                    pkg_name = dep
+                    version_spec = None
+                
                 # 尝试导入模块
-                module = importlib.import_module(pkg)
+                module = importlib.import_module(pkg_name)
                 
                 # 检查版本要求
-                if version_spec:
-                    if hasattr(module, "__version__"):
-                        installed_version = module.__version__
-                        
-                        # 解析版本规范
-                        if ">=" in version_spec:
-                            min_version = version_spec.split(">=")[1].strip()
-                            if parse_version(installed_version) < parse_version(min_version):
-                                version_issues.append(f"{pkg} (需要版本 >= {min_version}, 当前版本 {installed_version})")
-                        
-                        elif "<=" in version_spec:
-                            max_version = version_spec.split("<=")[1].strip()
-                            if parse_version(installed_version) > parse_version(max_version):
-                                version_issues.append(f"{pkg} (需要版本 <= {max_version}, 当前版本 {installed_version})")
-                        
-                        elif "==" in version_spec:
-                            exact_version = version_spec.split("==")[1].strip()
-                            if parse_version(installed_version) != parse_version(exact_version):
-                                version_issues.append(f"{pkg} (需要版本 == {exact_version}, 当前版本 {installed_version})")
-                        
-                        elif "!=" in version_spec:
-                            exclude_version = version_spec.split("!=")[1].strip()
-                            if parse_version(installed_version) == parse_version(exclude_version):
-                                version_issues.append(f"{pkg} (需要版本 != {exclude_version}, 当前版本 {installed_version})")
-                        
-                        elif ">" in version_spec:
-                            min_version = version_spec.split(">")[1].strip()
-                            if parse_version(installed_version) <= parse_version(min_version):
-                                version_issues.append(f"{pkg} (需要版本 > {min_version}, 当前版本 {installed_version})")
+                if version_spec and hasattr(module, "__version__"):
+                    installed_version = module.__version__
+                    if not self._check_version_constraint(installed_version, version_spec):
+                        version_issues.append(
+                            f"{pkg_name} (需要 {version_spec}, 当前 {installed_version})"
+                        )
                         
-                        elif "<" in version_spec:
-                            max_version = version_spec.split("<")[1].strip()
-                            if parse_version(installed_version) >= parse_version(max_version):
-                                version_issues.append(f"{pkg} (需要版本 < {max_version}, 当前版本 {installed_version})")
             except ModuleNotFoundError:
-                invalid.append(f"{pkg} (Module not found)")
+                missing.append(pkg_name)
             except ImportError:
-                missing.append(pkg)
+                invalid.append(f"{pkg_name} (导入失败)")
             except Exception as e:
-                invalid.append(f"{pkg} ({str(e)})")
-    
-        # 构建错误消息
-        error_msgs = []
-        if missing:
-            error_msgs.append(
-                f"缺少必要依赖包: {', '.join(missing)}\n"
-                f"请使用命令安装: pip install {' '.join(missing)}"
-            )
-        
-        if invalid:
-            error_msgs.append(
-                f"无效的依赖包: {', '.join(invalid)}\n"
-                f"请检查包名是否正确或尝试重新安装"
-            )
+                invalid.append(f"{pkg_name} ({str(e)})")
         
-        if version_issues:
-            error_msgs.append(
-                f"版本不兼容的依赖包: {', '.join(version_issues)}\n"
-                f"请使用命令升级: pip install --upgrade {' '.join([v.split(' ')[0] for v in version_issues])}"
-            )
+        # 如果有错误则抛出异常
+        if missing or invalid or version_issues:
+            error_msg = []
+            if missing:
+                error_msg.append(
+                    f"缺少依赖: {', '.join(missing)}\n"
+                    f"请安装: pip install {' '.join(missing)}"
+                )
+            if invalid:
+                error_msg.append(f"无效依赖: {', '.join(invalid)}")
+            if version_issues:
+                error_msg.append(f"版本冲突: {', '.join(version_issues)}")
+            
+            self._state = PluginState.ERROR
+            raise ImportError("\n".join(error_msg))
+    
+    def _check_version_constraint(self, version: str, constraint: str) -> bool:
+        """检查版本是否符合约束条件"""
+        current = parse_version(version)
         
-        if error_msgs:
-            raise ImportError("\n\n".join(error_msgs))
-
+        if ">=" in constraint:
+            required = parse_version(constraint.split(">=")[1])
+            return current >= required
+        elif "<=" in constraint:
+            required = parse_version(constraint.split("<=")[1])
+            return current <= required
+        elif "==" in constraint:
+            required = parse_version(constraint.split("==")[1])
+            return current == required
+        elif "!=" in constraint:
+            required = parse_version(constraint.split("!=")[1])
+            return current != required
+        elif ">" in constraint:
+            required = parse_version(constraint.split(">")[1])
+            return current > required
+        elif "<" in constraint:
+            required = parse_version(constraint.split("<")[1])
+            return current < required
+        else:
+            return True
+    
     def _check_metadata(self):
         """检查元数据是否被正确覆盖"""
         default_meta = PluginBase.metadata
@@ -162,12 +179,30 @@ class PluginBase(ABC):
         if current_meta.get("version") == "1.0.0":
             rich_print("[yellow]⚠️ 插件版本未定义，使用默认版本[/yellow]")
 
-    def get_plugin_name(self):
+    def get_plugin_name(self) -> str:
+        """获取插件名称"""
         return self.metadata['name']
-
+    
+    def get_state(self) -> PluginState:
+        """获取当前插件状态"""
+        return self._state
+    
+    def configure(self, config: Dict[str, Any]):
+        """配置插件"""
+        self._config.config.update(config)
+    
+    def initialize(self):
+        """初始化插件资源"""
+        self._state = PluginState.READY
+    
+    def cleanup(self):
+        """清理插件资源"""
+        self._state = PluginState.INITIALIZED
+    
     @abstractmethod
     def execute(self, data: Any) -> Any:
         """插件核心处理方法"""
+        self._state = PluginState.READY
         pass
 
     @classmethod
@@ -176,173 +211,338 @@ class PluginBase(ABC):
         return cls.metadata.copy()
 
 
-
-# 全局插件注册表（保持按优先级排序）
-_PLUGIN_REGISTRY: List[PluginBase] = []
-
-
-
-def load_plugin(
-    plugin_class: Type[PluginBase],
-    priority: int = None,
-    verbose: bool = False
-) -> bool:
-    """
-    加载并验证插件类
+class PluginManager:
+    """插件管理器，负责插件的加载、管理和执行"""
+    
+    def __init__(self):
+        self._plugins: List[PluginBase] = []
+        self._plugin_configs: Dict[str, PluginConfig] = {}
+        self._plugin_classes: Dict[str, Type[PluginBase]] = {}
+        self._config_file = "plugins_config.yaml"
+        
+        # 加载配置
+        self._load_config()
     
-    参数:
-        plugin_class: 必须继承自PluginBase的类
-        priority: 执行优先级（覆盖类默认值）
-        verbose: 是否显示加载详情
+    def _load_config(self):
+        """从配置文件加载插件配置"""
+        if os.path.exists(self._config_file):
+            with open(self._config_file, 'r') as f:
+                config_data = yaml.safe_load(f) or {}
+                for plugin_name, config in config_data.items():
+                    self._plugin_configs[plugin_name] = PluginConfig(**config)
+    
+    def _save_config(self):
+        """保存插件配置到文件"""
+        config_data = {}
+        for name, config in self._plugin_configs.items():
+            config_data[name] = {
+                "enabled": config.enabled,
+                "priority": config.priority,
+                "config": config.config
+            }
         
-    返回:
-        bool: 是否成功加载
-    """
-    try:
-        # 类型验证
-        if not issubclass(plugin_class, PluginBase):
-            raise TypeError("必须继承自PluginBase")
-            
-        # 实例化插件（自动触发依赖检查）
-        instance = plugin_class()
+        with open(self._config_file, 'w') as f:
+            yaml.safe_dump(config_data, f)
+    
+    def discover_plugins(self, directory: str = "plugins") -> List[str]:
+        """发现指定目录下的所有插件"""
+        plugin_dir = Path(directory)
+        if not plugin_dir.exists():
+            return []
         
-        # 设置优先级
-        if priority is not None:
-            instance.priority = priority
-        else:
-            instance.priority = plugin_class.priority
+        plugin_files = []
+        for file in plugin_dir.glob("**/*.py"):
+            if file.name.startswith("_"):
+                continue
+            plugin_files.append(str(file))
+        
+        return plugin_files
+    
+    def load_plugin_from_file(self, filepath: str) -> bool:
+        """从文件加载插件"""
+        try:
+            # 动态加载模块
+            module_name = os.path.splitext(os.path.basename(filepath))[0]
+            spec = importlib.util.spec_from_file_location(module_name, filepath)
+            if spec is None:
+                raise ImportError(f"无效的Python模块: {filepath}")
             
-        # 插入排序保持注册表有序
-        insert_pos = 0
-        while (insert_pos < len(_PLUGIN_REGISTRY) and 
-               _PLUGIN_REGISTRY[insert_pos].priority <= instance.priority):
-            insert_pos += 1
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
             
-        _PLUGIN_REGISTRY.insert(insert_pos, instance)
-        
-        if verbose:
-            meta = plugin_class.get_metadata()
-            print(
-                f"✅ 成功加载插件: {meta['name']} v{meta['version']}\n"
-                f"   作者: {meta['author']}\n"
-                f"   优先级: {instance.priority}\n"
-                f"   依赖: {plugin_class.required_packages}"
-            )
+            # 查找所有合法插件类
+            loaded = False
+            for name, obj in inspect.getmembers(module, inspect.isclass):
+                if (issubclass(obj, PluginBase) and 
+                    obj != PluginBase and 
+                    obj.__module__ == module.__name__):
+                    
+                    self._plugin_classes[name] = obj
+                    if name not in self._plugin_configs:
+                        self._plugin_configs[name] = PluginConfig()
+                    loaded = True
             
-        return True
+            return loaded
+        
+        except Exception as e:
+            rich_print(f"[red]加载插件 {filepath} 失败: {str(e)}[/red]")
+            return False
+    
+    def load_all_plugins(self, directory: str = "plugins") -> int:
+        """加载目录下的所有插件"""
+        plugin_files = self.discover_plugins(directory)
+        count = 0
+        for file in plugin_files:
+            if self.load_plugin_from_file(file):
+                count += 1
         
-    except Exception as e:
-        if verbose:
-            print(f"❌ 加载失败: {str(e)}")
-        return False
-
-
-
-@overload
-def execute_pipeline(data: List[Any] = None):
-    """按优先级顺序执行所有插件"""
-    ...
-
-
-@overload
-def execute_pipeline(data: Dict[str, Any] = None):
-    """按优先级顺序执行所有插件"""
-    ...
-
-
-def execute_pipeline(data: Any = None) -> dict:
-    """按优先级顺序执行所有插件"""
-    if isinstance(data, list):
-        res_dict = {}
-        for index, plugin in enumerate(_PLUGIN_REGISTRY):
-            result = plugin.execute(data[index])
-            res_dict[plugin.get_plugin_name()] = result
-        return res_dict
-    else:
-        res_dict = {}
-        for index, plugin in enumerate(_PLUGIN_REGISTRY):
-            result = plugin.execute(data[plugin.get_plugin_name()])
-            res_dict[plugin.get_plugin_name()] = result
-        return res_dict
-
-
-def execute_plugin_by_file(
-    filepath: str, 
-    data: Any = None,
-    plugin_class_name: str = None,
-    execute_all: bool = False
-) -> Union[Any, Dict[str, Any]]:
-    """
-    从Python文件加载并执行插件
+        rich_print(f"[green]成功加载 {count}/{len(plugin_files)} 个插件[/green]")
+        return count
     
-    参数:
-        filepath: Python文件路径
-        data: 传递给插件的数据
-        plugin_class_name: 指定要执行的插件类名(可选)
-        execute_all: 是否执行文件中所有插件(默认False)
+    def instantiate_plugin(self, plugin_name: str) -> Optional[PluginBase]:
+        """实例化指定插件"""
+        if plugin_name not in self._plugin_classes:
+            return None
         
-    返回:
-        单个插件结果 或 字典格式的{插件类名: 执行结果}
+        plugin_class = self._plugin_classes[plugin_name]
+        config = self._plugin_configs.get(plugin_name, PluginConfig())
         
-    异常:
-        ValueError: 当文件包含多个插件但未指定执行方式时
-        ImportError: 如果文件加载失败
-    """
-    import os
-    import importlib.util
-    from collections import OrderedDict
-
-    # 验证文件存在
-    if not os.path.exists(filepath):
-        raise FileNotFoundError(f"插件文件不存在: {filepath}")
+        try:
+            instance = plugin_class()
+            
+            # 应用配置
+            if config.priority is not None:
+                instance.priority = config.priority
+            if config.config:
+                instance.configure(config.config)
+            
+            # 初始化插件
+            instance.initialize()
+            
+            # 插入到插件列表并保持排序
+            self._insert_plugin_sorted(instance)
+            
+            return instance
+        except Exception as e:
+            rich_print(f"[red]实例化插件 {plugin_name} 失败: {str(e)}[/red]")
+            return None
+    
+    def _insert_plugin_sorted(self, plugin: PluginBase):
+        """按优先级将插件插入到正确位置"""
+        for i, p in enumerate(self._plugins):
+            if p.priority > plugin.priority:
+                self._plugins.insert(i, plugin)
+                return
+        self._plugins.append(plugin)
     
-    # 动态加载模块
-    module_name = os.path.splitext(os.path.basename(filepath))[0]
-    spec = importlib.util.spec_from_file_location(module_name, filepath)
-    if spec is None:
-        raise ImportError(f"无效的Python模块: {filepath}")
+    def get_plugin(self, plugin_name: str) -> Optional[PluginBase]:
+        """获取已加载的插件实例"""
+        for plugin in self._plugins:
+            if plugin.get_plugin_name() == plugin_name:
+                return plugin
+        return None
     
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
+    def get_all_plugins(self) -> List[PluginBase]:
+        """获取所有已加载插件"""
+        return self._plugins.copy()
     
-    # 查找所有合法插件类
-    plugin_classes = OrderedDict()
-    for name, obj in module.__dict__.items():
-        if (isinstance(obj, type) and 
-            issubclass(obj, PluginBase) and 
-            obj != PluginBase):
-            plugin_classes[name] = obj
+    def execute_plugin(self, plugin_name: str, data: Any) -> Any:
+        """执行指定插件"""
+        plugin = self.get_plugin(plugin_name)
+        if plugin is None:
+            raise ValueError(f"插件 {plugin_name} 未加载")
+        
+        if plugin.run_in_process:
+            return self._execute_in_process(plugin, data)
+        else:
+            return plugin.execute(data)
+    
+    def _execute_in_process(self, plugin: PluginBase, data: Any) -> Any:
+        """在独立进程中执行插件"""
+        def _worker(plugin_class: Type[PluginBase], data: Any, queue: Queue):
+            try:
+                instance = plugin_class()
+                instance.initialize()
+                result = instance.execute(data)
+                queue.put(("success", result))
+            except Exception as e:
+                queue.put(("error", str(e)))
+        
+        q = Queue()
+        p = Process(target=_worker, args=(plugin.__class__, data, q))
+        p.start()
+        p.join()
+        
+        status, result = q.get()
+        if status == "error":
+            raise RuntimeError(f"插件执行失败: {result}")
+        return result
     
-    # 处理插件类发现情况
-    if not plugin_classes:
-        raise AttributeError(f"文件中未找到有效的插件类(需继承PluginBase): {filepath}")
+    def execute_pipeline(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """按优先级顺序执行所有插件，支持插件特定的输入数据
+        
+        参数:
+            data: 字典格式，键为插件名称，值为该插件的输入数据
+            
+        返回:
+            字典格式的执行结果，键为插件名称，值为执行结果或错误信息
+            
+        示例:
+            >>> data = {
+            ...     "Plugin1": {"param1": "value1"},
+            ...     "Plugin2": [1, 2, 3]
+            ... }
+            >>> manager.execute_pipeline(data)
+            {
+                "Plugin1": {"result": "success"},
+                "Plugin2": {"error": "Invalid input"}
+            }
+        """
+        results = {}
+        for plugin in self._plugins:
+            plugin_name = plugin.get_plugin_name()
+            
+            # 检查插件是否启用
+            if not self._plugin_configs.get(plugin_name, PluginConfig()).enabled:
+                continue
+                
+            try:
+                # 获取该插件的输入数据，如果没有则为None
+                plugin_data = data.get(plugin_name)
+                
+                # 执行插件
+                results[plugin_name] = self.execute_plugin(plugin_name, plugin_data)
+                
+            except Exception as e:
+                rich_print(f"[red]插件 {plugin_name} 执行失败: {str(e)}[/red]")
+                results[plugin_name] = {
+                    "error": str(e),
+                    "type": type(e).__name__,
+                    "plugin": plugin_name
+                }
+        
+        return results
+
+    def reload_plugin(self, plugin_name: str) -> bool:
+        """重新加载插件"""
+        if plugin_name not in self._plugin_classes:
+            return False
+        
+        # 移除现有实例
+        self._plugins = [p for p in self._plugins if p.get_plugin_name() != plugin_name]
+        
+        # 重新实例化
+        return self.instantiate_plugin(plugin_name) is not None
     
-    # 多插件处理逻辑
-    if len(plugin_classes) > 1:
-        if not (plugin_class_name or execute_all):
-            raise ValueError(
-                f"文件中发现多个插件类: {list(plugin_classes.keys())}\n"
-                "请指定 plugin_class_name 或设置 execute_all=True"
+    def show_plugin_info(self):
+        """显示所有插件信息"""
+        table = Table(title="已加载插件", show_header=True, header_style="bold magenta")
+        table.add_column("名称", style="cyan")
+        table.add_column("版本", style="green")
+        table.add_column("作者")
+        table.add_column("描述")
+        table.add_column("优先级")
+        table.add_column("状态")
+        
+        for plugin in self._plugins:
+            meta = plugin.metadata
+            table.add_row(
+                meta["name"],
+                meta["version"],
+                meta["author"],
+                meta["description"],
+                str(plugin.priority),
+                plugin.get_state().name
             )
+        
+        rich_print(table)
     
-    # 执行单个指定插件
-    if plugin_class_name:
-        if plugin_class_name not in plugin_classes:
-            raise KeyError(f"插件类 '{plugin_class_name}' 不存在，可选: {list(plugin_classes.keys())}")
+    def set_plugin_priority(self, plugin_name: str, priority: int):
+        """设置插件优先级并重新排序"""
+        plugin = self.get_plugin(plugin_name)
+        if plugin is None:
+            raise ValueError(f"插件 {plugin_name} 未找到")
+        
+        plugin.priority = priority
+        self._plugins.remove(plugin)
+        self._insert_plugin_sorted(plugin)
         
-        plugin_class = plugin_classes[plugin_class_name]
-        if load_plugin(plugin_class, verbose=True):
-            return plugin_class().execute(data)
-        raise RuntimeError(f"插件加载失败: {plugin_class_name}")
+        # 更新配置
+        if plugin_name in self._plugin_configs:
+            self._plugin_configs[plugin_name].priority = priority
+            self._save_config()
     
-    # 执行所有插件
-    results = {}
-    for name, plugin_class in plugin_classes.items():
-        try:
-            if load_plugin(plugin_class, verbose=True):
-                results[name] = plugin_class().execute(data)
-        except Exception as e:
-            rich_print(f"[red]❌ 插件 {name} 执行失败: {str(e)}[/red]")
-            results[name] = {"error": str(e)}
+    def enable_plugin(self, plugin_name: str, enable: bool = True):
+        """启用或禁用插件"""
+        if plugin_name in self._plugin_configs:
+            self._plugin_configs[plugin_name].enabled = enable
+            self._save_config()
     
-    return results
+    def get_plugin_config(self, plugin_name: str) -> Optional[PluginConfig]:
+        """获取插件配置"""
+        return self._plugin_configs.get(plugin_name)
+    
+    def update_plugin_config(self, plugin_name: str, config: Dict[str, Any]):
+        """更新插件配置"""
+        if plugin_name in self._plugin_configs:
+            self._plugin_configs[plugin_name].config.update(config)
+            self._save_config()
+            
+            # 如果插件已加载，则应用新配置
+            plugin = self.get_plugin(plugin_name)
+            if plugin:
+                plugin.configure(config)
+
+
+# 全局插件管理器实例
+_plugin_manager = PluginManager()
+
+
+def get_plugin_manager() -> PluginManager:
+    """获取全局插件管理器实例"""
+    return _plugin_manager
+
+
+def load_plugins_from_directory(directory: str = "plugins") -> int:
+    """从目录加载所有插件"""
+    return _plugin_manager.load_all_plugins(directory)
+
+
+def execute_pipeline(data: Any) -> Dict[str, Any]:
+    """执行插件管道"""
+    return _plugin_manager.execute_pipeline(data)
+
+
+def show_plugin_info():
+    """显示插件信息"""
+    _plugin_manager.show_plugin_info()
+
+
+def reload_plugin(plugin_name: str) -> bool:
+    """重新加载插件"""
+    return _plugin_manager.reload_plugin(plugin_name)
+
+
+def set_plugin_priority(plugin_name: str, priority: int):
+    """设置插件优先级"""
+    _plugin_manager.set_plugin_priority(plugin_name, priority)
+
+
+def enable_plugin(plugin_name: str, enable: bool = True):
+    """启用或禁用插件"""
+    _plugin_manager.enable_plugin(plugin_name, enable)
+
+
+def get_plugin(plugin_name: str) -> Optional[PluginBase]:
+    """获取插件实例"""
+    return _plugin_manager.get_plugin(plugin_name)
+
+
+def execute_plugin(plugin_name: str, data: Any) -> Any:
+    """执行单个插件"""
+    return _plugin_manager.execute_plugin(plugin_name, data)
+
+
+def update_plugin_config(plugin_name: str, config: Dict[str, Any]):
+    """更新插件配置"""
+    _plugin_manager.update_plugin_config(plugin_name, config)