mofox-plugin-dev-toolkit 0.3.3__py3-none-any.whl

mpdt/utils/color_printer.py

@@ -0,0 +1,99 @@
+"""
+彩色输出工具
+"""
+
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from rich.tree import Tree
+
+console = Console()
+
+
+def print_success(message: str) -> None:
+    """打印成功消息"""
+    console.print(f"[bold green]✅ {message}[/bold green]")
+
+
+def print_error(message: str) -> None:
+    """打印错误消息"""
+    console.print(f"[bold red]❌ {message}[/bold red]")
+
+
+def print_warning(message: str) -> None:
+    """打印警告消息"""
+    console.print(f"[bold yellow]⚠️  {message}[/bold yellow]")
+
+
+def print_info(message: str) -> None:
+    """打印信息消息"""
+    console.print(f"[bold blue]ℹ️  {message}[/bold blue]")
+
+
+def print_step(message: str) -> None:
+    """打印步骤消息"""
+    console.print(f"[bold cyan]🔸 {message}[/bold cyan]")
+
+
+def print_panel(title: str, content: str, style: str = "green") -> None:
+    """打印面板"""
+    console.print(Panel(content, title=title, style=style))
+
+
+def print_table(title: str, columns: list[str], rows: list[list[str]]) -> None:
+    """打印表格"""
+    table = Table(title=title)
+
+    for col in columns:
+        table.add_column(col, style="cyan")
+
+    for row in rows:
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def print_tree(root_label: str, tree_data: dict[str, Any]) -> None:
+    """
+    打印树形结构
+    
+    Args:
+        root_label: 根节点标签
+        tree_data: 树形数据（字典或列表）
+    """
+    tree = Tree(f"[bold blue]{root_label}[/bold blue]")
+
+    def add_branch(parent: Tree, data: Any) -> None:
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    branch = parent.add(f"[cyan]{key}/[/cyan]")
+                    add_branch(branch, value)
+                else:
+                    parent.add(f"[green]{key}[/green]")
+        elif isinstance(data, list):
+            for item in data:
+                if isinstance(item, str):
+                    parent.add(f"[green]{item}[/green]")
+                else:
+                    add_branch(parent, item)
+
+    add_branch(tree, tree_data)
+    console.print(tree)
+
+
+def create_progress() -> Progress:
+    """创建进度条"""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    )
+
+
+def print_divider(char: str = "━", length: int = 80) -> None:
+    """打印分割线"""
+    console.print(char * length, style="dim")

mpdt/utils/config_loader.py

@@ -0,0 +1,171 @@
+"""
+配置加载器
+"""
+
+from pathlib import Path
+from typing import Any
+
+import toml
+
+
+class ConfigLoader:
+    """配置加载器"""
+
+    def __init__(self, config_path: Path | str | None = None):
+        """
+        初始化配置加载器
+        
+        Args:
+            config_path: 配置文件路径
+        """
+        self.config_path = Path(config_path) if config_path else None
+        self.config: dict[str, Any] = {}
+
+        if self.config_path and self.config_path.exists():
+            self.load()
+
+    def load(self) -> dict[str, Any]:
+        """
+        加载配置文件
+        
+        Returns:
+            配置字典
+        """
+        if not self.config_path or not self.config_path.exists():
+            return {}
+
+        self.config = toml.load(str(self.config_path))
+        return self.config
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        获取配置项
+        
+        支持点号分隔的嵌套键，例如: "mpdt.check.level"
+        
+        Args:
+            key: 配置键
+            default: 默认值
+            
+        Returns:
+            配置值
+        """
+        keys = key.split(".")
+        value = self.config
+
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        设置配置项
+        
+        Args:
+            key: 配置键
+            value: 配置值
+        """
+        keys = key.split(".")
+        config = self.config
+
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+
+        config[keys[-1]] = value
+
+    def save(self, path: Path | str | None = None) -> None:
+        """
+        保存配置到文件
+        
+        Args:
+            path: 保存路径，如果为 None 则使用初始化时的路径
+        """
+        save_path = Path(path) if path else self.config_path
+
+        if not save_path:
+            raise ValueError("未指定配置文件路径")
+
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(save_path, "w", encoding="utf-8") as f:
+            toml.dump(self.config, f)
+
+
+def load_mpdt_config(project_dir: Path | str = ".") -> ConfigLoader:
+    """
+    加载 MPDT 配置文件
+    
+    优先级:
+    1. .mpdtrc.toml
+    2. pyproject.toml 中的 [tool.mpdt] 部分
+    
+    Args:
+        project_dir: 项目目录
+        
+    Returns:
+        ConfigLoader 对象
+    """
+    project_dir = Path(project_dir)
+
+    # 首先尝试加载 .mpdtrc.toml
+    mpdtrc_path = project_dir / ".mpdtrc.toml"
+    if mpdtrc_path.exists():
+        return ConfigLoader(mpdtrc_path)
+
+    # 然后尝试从 pyproject.toml 加载
+    pyproject_path = project_dir / "pyproject.toml"
+    if pyproject_path.exists():
+        config = toml.load(str(pyproject_path))
+        if "tool" in config and "mpdt" in config["tool"]:
+            loader = ConfigLoader()
+            loader.config = config["tool"]["mpdt"]
+            return loader
+
+    # 返回空配置
+    return ConfigLoader()
+
+
+def get_default_config() -> dict[str, Any]:
+    """
+    获取默认配置
+    
+    Returns:
+        默认配置字典
+    """
+    return {
+        "mpdt": {
+            "version": "0.1.2",
+        },
+        "check": {
+            "level": "warning",
+            "auto_fix": False,
+            "ignore_patterns": ["tests/*", "*.pyc", "__pycache__/*"],
+        },
+        "test": {
+            "coverage_threshold": 80,
+            "pytest_args": ["-v", "--tb=short"],
+        },
+        "build": {
+            "output_dir": "dist",
+            "include_docs": True,
+            "include_tests": False,
+            "format": "zip",
+        },
+        "dev": {
+            "port": 8080,
+            "host": "127.0.0.1",
+            "reload": True,
+            "check_on_save": True,
+        },
+        "templates": {
+            "author": "",
+            "license": "GPL-v3.0",
+            "python_version": "^3.11",
+        },
+    }

mpdt/utils/config_manager.py

@@ -0,0 +1,297 @@
+"""
+MPDT 配置管理器
+管理 mofox 路径、虚拟环境等配置信息
+"""
+
+import os
+from pathlib import Path
+from typing import Literal
+
+try:
+    import tomli
+    import tomli_w
+except ImportError:
+    # 如果没有安装 tomli，使用 toml
+    try:
+        import toml as tomli
+        import toml as tomli_w
+    except ImportError:
+        tomli = None
+        tomli_w = None
+
+VenvType = Literal["venv", "uv", "conda", "poetry", "none"]
+
+
+class MPDTConfig:
+    """MPDT 配置管理器"""
+
+    def __init__(self, config_path: Path | None = None):
+        """初始化配置管理器
+        
+        Args:
+            config_path: 配置文件路径，默认为 ~/.mpdt/config.toml
+        """
+        if config_path is None:
+            config_path = Path.home() / ".mpdt" / "config.toml"
+
+        self.config_path = config_path
+        self._config: dict = {}
+
+        # 加载配置
+        if self.config_path.exists():
+            self.load()
+
+    def load(self) -> None:
+        """加载配置文件"""
+        if not self.config_path.exists():
+            self._config = {}
+            return
+
+        if tomli is None:
+            raise ImportError("需要安装 tomli 库来读取配置文件")
+
+        with open(self.config_path, "rb") as f:
+            self._config = tomli.load(f)
+
+    def save(self) -> None:
+        """保存配置文件"""
+        if tomli_w is None:
+            raise ImportError("需要安装 tomli-w 库来写入配置文件")
+
+        # 确保目录存在
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(self.config_path, "wb") as f:
+            tomli_w.dump(self._config, f)
+
+    @property
+    def mofox_path(self) -> Path | None:
+        """获取 mofox 主程序路径"""
+        path_str = self._config.get("mofox", {}).get("path")
+        return Path(path_str) if path_str else None
+
+    @mofox_path.setter
+    def mofox_path(self, path: Path | str) -> None:
+        """设置 mofox 主程序路径"""
+        if "mofox" not in self._config:
+            self._config["mofox"] = {}
+        self._config["mofox"]["path"] = str(Path(path).absolute())
+
+    @property
+    def venv_path(self) -> Path | None:
+        """获取虚拟环境路径"""
+        path_str = self._config.get("mofox", {}).get("venv_path")
+        return Path(path_str) if path_str else None
+
+    @venv_path.setter
+    def venv_path(self, path: Path | str | None) -> None:
+        """设置虚拟环境路径"""
+        if "mofox" not in self._config:
+            self._config["mofox"] = {}
+        if path is None:
+            self._config["mofox"]["venv_path"] = None
+        else:
+            self._config["mofox"]["venv_path"] = str(Path(path).absolute())
+
+    @property
+    def venv_type(self) -> VenvType:
+        """获取虚拟环境类型"""
+        return self._config.get("mofox", {}).get("venv_type", "venv")
+
+    @venv_type.setter
+    def venv_type(self, venv_type: VenvType) -> None:
+        """设置虚拟环境类型"""
+        if "mofox" not in self._config:
+            self._config["mofox"] = {}
+        self._config["mofox"]["venv_type"] = venv_type
+
+    @property
+    def auto_reload(self) -> bool:
+        """是否自动重载"""
+        return self._config.get("dev", {}).get("auto_reload", True)
+
+    @auto_reload.setter
+    def auto_reload(self, value: bool) -> None:
+        """设置是否自动重载"""
+        if "dev" not in self._config:
+            self._config["dev"] = {}
+        self._config["dev"]["auto_reload"] = value
+
+    @property
+    def reload_delay(self) -> float:
+        """重载延迟（秒）"""
+        return self._config.get("dev", {}).get("reload_delay", 0.3)
+
+    @reload_delay.setter
+    def reload_delay(self, value: float) -> None:
+        """设置重载延迟"""
+        if "dev" not in self._config:
+            self._config["dev"] = {}
+        self._config["dev"]["reload_delay"] = value
+
+    def get_python_command(self) -> list[str]:
+        """获取 Python 启动命令
+        
+        Returns:
+            Python 命令列表，例如:
+            - ["E:/venv/Scripts/python.exe"]
+            - ["conda", "run", "-p", "E:/conda_env", "python"]
+            - ["poetry", "run", "python"]
+        """
+        venv_type = self.venv_type
+        venv_path = self.venv_path
+
+        if venv_type == "none" or not venv_path:
+            return ["python"]
+
+        if venv_type == "venv" or venv_type == "uv":
+            # venv 和 uv 使用相同的结构
+            if os.name == "nt":  # Windows
+                python_exe = venv_path / "Scripts" / "python.exe"
+            else:  # Unix-like
+                python_exe = venv_path / "bin" / "python"
+
+            if python_exe.exists():
+                return [str(python_exe)]
+            else:
+                # 降级到系统 Python
+                return ["python"]
+
+        elif venv_type == "conda":
+            return ["conda", "run", "-p", str(venv_path), "python"]
+
+        elif venv_type == "poetry":
+            # poetry 需要在 mofox 目录中执行
+            return ["poetry", "run", "python"]
+
+        else:
+            return ["python"]
+
+    def validate(self) -> tuple[bool, list[str]]:
+        """验证配置
+        
+        Returns:
+            (是否有效, 错误消息列表)
+        """
+        errors = []
+
+        # 检查 mofox 路径
+        if not self.mofox_path:
+            errors.append("未配置 mofox 主程序路径")
+        elif not self.mofox_path.exists():
+            errors.append(f"mofox 路径不存在: {self.mofox_path}")
+        else:
+            # 检查是否有 bot.py
+            bot_file = self.mofox_path / "bot.py"
+            if not bot_file.exists():
+                errors.append(f"未找到 bot.py: {bot_file}")
+
+        # 检查虚拟环境
+        if self.venv_type != "none" and self.venv_path:
+            if not self.venv_path.exists():
+                errors.append(f"虚拟环境路径不存在: {self.venv_path}")
+            else:
+                # 检查 Python 可执行文件
+                python_cmd = self.get_python_command()
+                if self.venv_type in ["venv", "uv"]:
+                    python_path = Path(python_cmd[0])
+                    if not python_path.exists():
+                        errors.append(f"Python 可执行文件不存在: {python_path}")
+
+        return len(errors) == 0, errors
+
+    def is_configured(self) -> bool:
+        """检查是否已配置"""
+        return self.mofox_path is not None
+
+
+def get_default_config() -> MPDTConfig:
+    """获取默认配置实例"""
+    return MPDTConfig()
+
+
+def interactive_config() -> MPDTConfig:
+    """交互式配置向导
+    
+    Returns:
+        配置好的 MPDTConfig 实例
+    """
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.prompt import Confirm, Prompt
+
+    console = Console()
+    config = MPDTConfig()
+
+    console.print(Panel.fit(
+        "[bold cyan]MPDT 配置向导[/bold cyan]\n\n"
+        "让我们配置 MoFox 主程序的路径和虚拟环境"
+    ))
+
+    # 配置 mofox 路径
+    while True:
+        mofox_path_str = Prompt.ask(
+            "\n[bold]请输入 mofox 主程序路径[/bold]",
+            default=str(Path.cwd().parent / "mofox") if Path.cwd().parent.name != "mofox" else str(Path.cwd())
+        )
+        mofox_path = Path(mofox_path_str).expanduser().absolute()
+
+        if not mofox_path.exists():
+            console.print(f"[red]路径不存在: {mofox_path}[/red]")
+            if not Confirm.ask("重新输入?", default=True):
+                break
+            continue
+
+        bot_file = mofox_path / "bot.py"
+        if not bot_file.exists():
+            console.print("[yellow]警告: 未找到 bot.py[/yellow]")
+            if not Confirm.ask("仍然使用此路径?", default=False):
+                continue
+
+        config.mofox_path = mofox_path
+        console.print(f"[green]✓ mofox 路径已设置: {mofox_path}[/green]")
+        break
+
+    # 配置虚拟环境
+    console.print("\n[bold]虚拟环境配置[/bold]")
+    venv_type_choice = Prompt.ask(
+        "请选择虚拟环境类型",
+        choices=["venv", "uv", "conda", "poetry", "none"],
+        default="venv"
+    )
+    config.venv_type = venv_type_choice
+
+    if venv_type_choice != "none":
+        if venv_type_choice == "poetry":
+            console.print("[cyan]使用 poetry，将在 mofox 目录中执行命令[/cyan]")
+            config.venv_path = config.mofox_path
+        else:
+            default_venv_path = str(config.mofox_path.parent / "venv")
+            if venv_type_choice == "uv":
+                default_venv_path = str(config.mofox_path.parent / ".venv")
+            elif venv_type_choice == "conda":
+                default_venv_path = str(config.mofox_path.parent / "conda_env")
+
+            venv_path_str = Prompt.ask(
+                f"请输入 {venv_type_choice} 虚拟环境路径",
+                default=default_venv_path
+            )
+            venv_path = Path(venv_path_str).expanduser().absolute()
+
+            if not venv_path.exists():
+                console.print(f"[yellow]警告: 虚拟环境路径不存在: {venv_path}[/yellow]")
+                if not Confirm.ask("仍然使用此路径?", default=True):
+                    config.venv_type = "none"
+                else:
+                    config.venv_path = venv_path
+            else:
+                config.venv_path = venv_path
+                console.print(f"[green]✓ 虚拟环境路径已设置: {venv_path}[/green]")
+    else:
+        console.print("[cyan]将使用系统 Python[/cyan]")
+
+    # 保存配置
+    config.save()
+    console.print(f"\n[bold green]✓ 配置已保存: {config.config_path}[/bold green]")
+
+    return config