py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/initenv/components/pyproject_generator.py

@@ -0,0 +1,194 @@
+"""PyProject.toml generator utility."""
+
+import re
+from pathlib import Path
+from typing import Any
+
+import toml
+
+from ....utils.logging import log_debug
+from .config_manager import ConfigManager
+from .project_structure.directory_creator import normalize_project_name
+
+
+def clean_cargo_name(name: str) -> str:
+    """Cleans a string to be a valid Cargo package name.
+    - Replaces invalid characters (anything not letter, number, _, -) with underscore.
+    - Ensures it doesn't start/end with invalid chars like _ or -.
+    """
+    # Replace sequences of invalid characters (anything not alphanumeric or _) with a single underscore
+    # Also replace hyphens with underscores as Cargo prefers underscores, though hyphens are technically allowed.
+    cleaned = re.sub(r"[^a-zA-Z0-9_]+", "_", name.replace("-", "_"))
+    # Remove leading/trailing underscores
+    cleaned = cleaned.strip("_")
+    # Handle potential empty string after cleaning
+    if not cleaned:
+        return "rust_package"  # Default fallback name
+    # Ensure it doesn't start with a digit (invalid for Rust identifiers)
+    if cleaned[0].isdigit():
+        cleaned = "_" + cleaned
+    return cleaned
+
+
+def dump_toml(data: dict[str, Any], file_path: str) -> None:
+    """将数据以 TOML 格式写入文件"""
+    with open(file_path, "w", encoding="utf-8") as f:
+        toml.dump(data, f)
+
+
+class PyProjectGenerator:
+    """pyproject.toml 生成器类"""
+
+    def __init__(self, project_name: str) -> None:
+        self.cleaned_python_name = normalize_project_name(project_name)
+        self.cleaned_rust_name = clean_cargo_name(f"{project_name}_native")
+        self.config: dict[str, Any] = {}
+        self.config_manager = ConfigManager()
+
+    def _load_tool_configs(self) -> dict[str, Any]:
+        """加载工具配置"""
+        result = self.config_manager.load_vendor_config("config/tool_configs.toml")
+        return result or {}
+
+    def _load_dependencies(self) -> list[str]:
+        """加载依赖列表"""
+        dependencies_config = self.config_manager.load_vendor_config(
+            "config/dependencies.toml"
+        )
+        return dependencies_config.get("dependencies", {}).get("default", []) or []
+
+    def set_project_info(
+        self,
+        description: str | None = None,
+        authors: list[dict[str, str]] | None = None,
+        python_version: str = ">=3.12",
+        license_name: str = "MIT",
+        dependencies: list[str] | None = None,
+    ) -> None:
+        """设置项目基本信息"""
+        # Load dependencies from config if not provided
+        if not dependencies:
+            dependencies = self._load_dependencies()
+
+        # Use cleaned python name for URLs and description default
+        project_urls = {
+            "Homepage": f"https://github.com/example/{self.cleaned_python_name}",
+            "Issues": f"https://github.com/example/{self.cleaned_python_name}/issues",
+        }
+
+        self.config["project"] = {
+            "name": self.cleaned_python_name,
+            "dynamic": ["version"],
+            "description": description or f"{self.cleaned_python_name} - Python项目",
+            "requires-python": python_version,
+            "license": license_name,
+            "readme": "README.md",
+            "dependencies": dependencies,
+            "authors": authors or [{"name": "Admin", "email": "admin@example.com"}],
+            "urls": project_urls,
+        }
+
+    def set_build_system(self, is_rust: bool = False) -> None:
+        """设置构建系统配置"""
+        if not is_rust:
+            log_debug("Non-Rust build system not fully configured in generator.")
+            # Set a basic setuptools build system or similar if required
+            self.config["build-system"] = {
+                "requires": ["setuptools>=61.0"],
+                "build-backend": "setuptools.build_meta",
+            }
+            return  # Exit early if not using Rust/Maturin
+
+        # --- Maturin Configuration ---
+        self.config["build-system"] = {
+            "requires": ["maturin>=1.0,<2.0"],
+            "build-backend": "maturin",
+        }
+
+        # Maturin 特定配置
+        maturin_config = {
+            "manifest-path": "rust/Cargo.toml",
+            # Use CLEANED Python and Rust names for module-name
+            "module-name": f"{self.cleaned_python_name}.lib.{self.cleaned_rust_name}",
+            "python-source": "src",
+            # Use cleaned python name for include path
+            "include": [f"src/{self.cleaned_python_name}/**/*"],
+            "bindings": "pyo3",
+            "features": ["pyo3/extension-module"],
+            "sdist-include": ["src/**/*"],
+            # Use cleaned python name for python-packages
+            "python-packages": [self.cleaned_python_name],
+        }
+
+        self.config["tool"] = self.config.get("tool", {})
+        self.config["tool"]["maturin"] = maturin_config
+
+    def set_development_tools(self) -> None:
+        """设置开发工具配置"""
+        tool_configs = self._load_tool_configs()
+
+        log_debug(f"Loaded tool_configs keys: {list(tool_configs.keys())}")
+        if "tool" in tool_configs:
+            log_debug(f"tool_configs['tool'] keys: {list(tool_configs['tool'].keys())}")
+
+        self.config["tool"] = self.config.get("tool", {})
+        self.config["tool"].update(tool_configs.get("tool", {}))
+
+    def set_entry_points(self, entry_points: dict[str, Any]) -> None:
+        """设置入口点"""
+        if "project" not in self.config:
+            self.config["project"] = {}
+
+        if "scripts" in entry_points:
+            self.config["project"]["scripts"] = entry_points["scripts"]
+        if "gui_scripts" in entry_points:
+            self.config["project"]["gui-scripts"] = entry_points["gui_scripts"]
+
+    def generate_package_pyproject(
+        self, output_path: str, is_rust: bool = False
+    ) -> None:
+        """Generate pyproject.toml for a workspace sub-package (e.g. packages/{name}/).
+
+        Args:
+            output_path: Path to write the pyproject.toml file.
+            is_rust: Whether to include Rust/maturin build configuration.
+        """
+        pkg_config: dict[str, Any] = {
+            "project": {
+                "name": self.cleaned_python_name,
+                "version": "0.1.0",
+                "description": f"{self.cleaned_python_name} - Python项目",
+                "requires-python": ">=3.12",
+                "readme": "README.md",
+                "dependencies": self._load_dependencies(),
+            },
+        }
+
+        if is_rust:
+            pkg_config["build-system"] = {
+                "requires": ["maturin>=1.0,<2.0"],
+                "build-backend": "maturin",
+            }
+            pkg_config["tool"] = {
+                "maturin": {
+                    "manifest-path": "rust/Cargo.toml",
+                    "module-name": f"{self.cleaned_python_name}.lib.{self.cleaned_rust_name}",
+                    "python-source": "src",
+                    "bindings": "pyo3",
+                    "features": ["pyo3/extension-module"],
+                },
+            }
+
+        dump_toml(pkg_config, output_path)
+
+    def generate(self, output_path: str = "pyproject.toml") -> None:
+        """生成 pyproject.toml 文件"""
+        is_rust = Path("rust").exists()
+
+        if "project" not in self.config:
+            self.set_project_info()
+        self.set_development_tools()
+        if "build-system" not in self.config:
+            self.set_build_system(is_rust=is_rust)
+
+        dump_toml(self.config, output_path)

wl_cli/commands/initenv/components/rust_initializer.py

@@ -0,0 +1,145 @@
+"""Custom exceptions for initenv commands."""
+
+import shutil
+from pathlib import Path
+
+from ....utils.logging import log_debug, log_debug_pair, log_info_pair
+from ..common.exceptions import InitEnvError
+from .log_manager import performance_monitor
+from .pyproject_generator import clean_cargo_name  # Import the cleaning function
+
+
+class RustInitializer:
+    """Rust environment initializer."""
+
+    def __init__(self) -> None:
+        pass
+
+    @performance_monitor
+    def initialize(self) -> None:
+        """Initialize Rust environment."""
+        rust_dir = Path("rust")
+
+        # Create rust directory if it doesn't exist
+        if not rust_dir.exists():
+            log_debug_pair("Creating rust directory...", "创建rust目录...")
+            rust_dir.mkdir(exist_ok=True)
+
+        # Check if Cargo.toml exists
+        cargo_toml_path = rust_dir / "Cargo.toml"
+        if cargo_toml_path.exists():
+            log_debug_pair(
+                "Cargo.toml already exists, skipping creation",
+                "Cargo.toml 已存在，跳过创建",
+            )
+            return
+
+        # Use project template files instead of cargo init
+        log_debug_pair(
+            "Initializing Rust project with project template...",
+            "使用项目模板初始化Rust项目...",
+        )
+        try:
+            # Get the template directory path
+            # Calculate path to vendors/rust directory relative to this file
+            # File is in src/wl_cli/commands/initenv/utils/
+            # vendors dir is in src/wl_cli/
+            # So we need to go up 4 levels
+            template_dir = (
+                Path(__file__).parent.parent.parent.parent / "vendors" / "rust"
+            )
+
+            log_debug(f"Template directory: {template_dir}")
+
+            if not template_dir.exists():
+                raise InitEnvError(f"Rust template directory not found: {template_dir}")
+
+            # Get project name from current directory
+            project_name = Path.cwd().name
+
+            # Copy template files to rust directory
+            for item in template_dir.iterdir():
+                dest_path = rust_dir / item.name
+                if item.is_dir():
+                    shutil.copytree(item, dest_path, dirs_exist_ok=True)
+                else:
+                    # Special handling for Cargo.toml to replace project name
+                    if item.name == "Cargo.toml":
+                        self._copy_and_update_cargo_toml(item, dest_path, project_name)
+                    else:
+                        shutil.copy2(item, dest_path)
+
+            # Update lib.rs with the correct module name
+            lib_rs_path = rust_dir / "src" / "lib.rs"
+            if lib_rs_path.exists():
+                self._update_lib_rs(lib_rs_path, project_name)
+
+            log_info_pair(
+                "✓ Rust project initialized successfully with template",
+                "✓ 使用模板成功初始化Rust项目",
+            )
+        except Exception as e:
+            raise InitEnvError(f"Failed to initialize Rust project: {e}")
+
+    def _copy_and_update_cargo_toml(
+        self, source: Path, dest: Path, project_name: str
+    ) -> None:
+        """Copy Cargo.toml template and update project name."""
+        # Read the template file
+        with open(source, encoding="utf-8") as f:
+            content = f.read()
+
+        # Clean the project name to be a valid Cargo name
+        cleaned_project_name = clean_cargo_name(project_name)
+        # Ensure the library name uses underscores, not hyphens
+        lib_name = cleaned_project_name + "_native"
+
+        # Warn users if their project name contains hyphens
+        if "-" in project_name:
+            log_info_pair(
+                "Warning: Project name contains hyphens which are not allowed in Rust library names.",
+                "警告: 项目名称包含连字符，这在Rust库名称中是不允许的。",
+            )
+            log_info_pair(
+                "         Converting to underscores for Rust compatibility.",
+                "      已转换为下划线以确保与Rust兼容。",
+            )
+
+        # Replace the template project name with actual project name
+        # Replace both the package name and the lib name
+        updated_content = content.replace("wl_cli_native", lib_name)
+        # Also replace in the [lib] section to ensure library name is correct
+        updated_content = updated_content.replace(
+            'name = "wl_cli_native"', f'name = "{lib_name}"'
+        )
+
+        # Write the updated content to destination
+        with open(dest, "w", encoding="utf-8") as f:
+            f.write(updated_content)
+
+    def _update_lib_rs(self, lib_rs_path: Path, project_name: str) -> None:
+        """Update lib.rs with the correct module name."""
+        # Read the template file
+        with open(lib_rs_path, encoding="utf-8") as f:
+            content = f.read()
+
+        # Clean the project name to be a valid Cargo name
+        cleaned_project_name = clean_cargo_name(project_name)
+        # Ensure the library name uses underscores, not hyphens
+        lib_name = cleaned_project_name + "_native"
+
+        # Warn users if their project name contains hyphens
+        if "-" in project_name:
+            log_info_pair(
+                "Warning: Project name contains hyphens which are not allowed in Rust library names.",
+                "警告: 项目名称包含连字符，这在Rust库名称中是不允许的。",
+            )
+            log_info_pair(
+                "         Converting to underscores for Rust compatibility.",
+                "      已转换为下划线以确保与Rust兼容。",
+            )
+
+        # Replace the template project name with actual project name in lib.rs
+        updated_content = content.replace("wl_cli_native", lib_name)
+        with open(lib_rs_path, "w", encoding="utf-8") as f:
+            f.write(updated_content)

wl_cli/commands/initenv/components/symlink_cleaner.py

@@ -0,0 +1,99 @@
+"""
+Symlink cleaning utilities for deployment functionality.
+"""
+
+import os
+
+
+def _clean_file_symlinks(root: str, files: list[str], source_dir_basename: str) -> int:
+    """
+    清理文件软链接
+
+    Args:
+        root: 根目录路径
+        files: 文件列表
+        source_dir_basename: 源目录基本名称
+
+    Returns:
+        int: 清理的链接数量
+    """
+    cleaned_count = 0
+    for file in files:
+        file_path = os.path.join(root, file)
+        if os.path.islink(file_path):
+            try:
+                link_target = os.readlink(file_path)
+                if source_dir_basename in link_target:
+                    os.unlink(file_path)
+                    cleaned_count += 1
+            except OSError:
+                pass
+    return cleaned_count
+
+
+def _clean_directory_symlinks(
+    root: str, dirs: list[str], source_dir_basename: str
+) -> tuple[int, list[str]]:
+    """
+    清理目录软链接
+
+    Args:
+        root: 根目录路径
+        dirs: 目录列表
+        source_dir_basename: 源目录基本名称
+
+    Returns:
+        tuple[int, list[str]]: (清理的链接数量, 需要从遍历中移除的目录列表)
+    """
+    cleaned_count = 0
+    removed_dirs = []
+    for dir_name in dirs[:]:  # 使用副本进行迭代，因为我们可能会修改dirs
+        dir_path = os.path.join(root, dir_name)
+        if os.path.islink(dir_path):
+            try:
+                link_target = os.readlink(dir_path)
+                if source_dir_basename in link_target:
+                    os.unlink(dir_path)
+                    cleaned_count += 1
+                    removed_dirs.append(dir_name)  # 记录需要移除的目录
+            except OSError:
+                pass
+    return cleaned_count, removed_dirs
+
+
+def clean_existing_symlinks(
+    py_dirs: list[str], source_dir_name: str = "shared-build-system"
+) -> int:
+    """
+    清理目标文件夹中已有的软链接
+    """
+    cleaned_count = 0
+    source_dir_basename = os.path.basename(source_dir_name)
+
+    for py_dir in py_dirs:
+        if not os.path.exists(py_dir):
+            continue
+
+        # 递归清理子目录中的链接
+        try:
+            for root, dirs, files in os.walk(py_dir):
+                # 清理文件链接
+                cleaned_count += _clean_file_symlinks(root, files, source_dir_basename)
+
+                # 清理目录链接
+                dir_cleaned_count, removed_dirs = _clean_directory_symlinks(
+                    root, dirs, source_dir_basename
+                )
+                cleaned_count += dir_cleaned_count
+
+                # 从遍历列表中移除已清理的目录
+                for removed_dir in removed_dirs:
+                    try:
+                        dirs.remove(removed_dir)
+                    except ValueError:
+                        pass  # 目录不在列表中，忽略
+
+        except OSError:
+            pass
+
+    return cleaned_count

wl_cli/commands/initenv/components/symlink_manager.py

@@ -0,0 +1,52 @@
+"""
+Symlink management utilities for deployment.
+"""
+
+import os
+import shutil
+
+from ....utils.platform_adapter import PlatformAdapter
+
+
+def create_symlink(source: str, target: str) -> bool:
+    """
+    创建从源到目标的软链接，处理平台差异
+    """
+    source = os.path.abspath(source)
+    target = os.path.abspath(target)
+
+    # 如果目标文件已存在，先删除
+    if os.path.exists(target):
+        try:
+            if os.path.islink(target):
+                os.unlink(target)
+            elif os.path.isdir(target):
+                shutil.rmtree(target)
+            elif os.path.isfile(target):
+                os.remove(target)
+        except OSError:
+            return False
+
+    # 确保目标目录存在
+    target_dir = os.path.dirname(target)
+    try:
+        os.makedirs(target_dir, exist_ok=True)
+    except OSError:
+        return False
+
+    # 创建软链接（处理不同操作系统）
+    try:
+        if PlatformAdapter.is_windows():
+            # Windows 需要管理员权限并区分目录和文件链接
+            is_directory = os.path.isdir(source)
+            if is_directory:
+                # Windows 10以上版本支持目录符号链接，低版本需使用junction
+                os.symlink(source, target, target_is_directory=True)
+            else:
+                os.symlink(source, target)
+        else:
+            # Unix/Linux/macOS
+            os.symlink(source, target)
+        return True
+    except OSError:
+        return False

wl_cli/commands/initenv/components/venv_manager.py

@@ -0,0 +1,118 @@
+"""Virtual environment manager utility."""
+
+import subprocess
+
+from ....utils.logging import log_info, log_info_pair
+from ....utils.platform_adapter import PlatformAdapter
+from .log_manager import performance_monitor
+
+
+class VenvManager:
+    """Virtual environment manager."""
+
+    def __init__(self, env: dict[str, str]) -> None:
+        self.env = env
+
+    @performance_monitor
+    def create_venv(
+        self, venv_path: str, _: str, env: dict[str, str] | None = None
+    ) -> bool:
+        """Create a virtual environment, retrying on Windows when needed.
+
+        The platform differences live on :class:`PlatformAdapter`: it supplies
+        the primary argv (``python -m uv`` on Windows, ``uv`` elsewhere) and,
+        on Windows only, a retry argv for when the interpreter cannot find uv
+        as a module.
+
+        Args:
+            venv_path: Destination directory for the virtual environment.
+            _: Python version; currently informational only.
+            env: Environment for the subprocess. Defaults to this manager's
+                own environment; the Windows caller relies on that default.
+
+        Returns:
+            True if the environment was created, False otherwise.
+        """
+        process_env = self.env if env is None else env
+
+        try:
+            cmd = PlatformAdapter.get_venv_create_command(venv_path)
+            fallback_cmd = PlatformAdapter.get_venv_create_fallback_command(venv_path)
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, env=process_env, encoding="utf-8"
+            )
+
+            # If the interpreter cannot find uv as a module, retry with the uv
+            # command directly (Windows only -- fallback_cmd is None elsewhere).
+            if (
+                result.returncode != 0
+                and fallback_cmd is not None
+                and "No module named uv" in result.stderr
+            ):
+                log_info("uv module not found, trying uv command directly...")
+                result = subprocess.run(
+                    fallback_cmd,
+                    capture_output=True,
+                    text=True,
+                    env=process_env,
+                    encoding="utf-8",
+                )
+
+            if result.returncode == 0:
+                log_info_pair(
+                    f"✓ Virtual environment created at {venv_path}",
+                    f"✓ 虚拟环境已在 {venv_path} 创建",
+                )
+                return True
+            else:
+                log_info_pair(
+                    f"Warning: Failed to create virtual environment: {result.stderr}",
+                    f"警告: 创建虚拟环境失败: {result.stderr}",
+                )
+                return False
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to create virtual environment: {e}",
+                f"警告: 创建虚拟环境失败: {e}",
+            )
+            return False
+
+    @performance_monitor
+    def sync_environment(self, _venv_path: str = ".venv") -> bool:
+        """Sync the environment by updating dependencies."""
+        log_info_pair(
+            "Syncing environment dependencies...",
+            "同步环境依赖...",
+        )
+
+        try:
+            # 更新依赖
+            log_info_pair(
+                "Updating dependencies with uv...",
+                "使用uv更新依赖...",
+            )
+            cmd = ["uv", "sync"]
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, env=self.env, encoding="utf-8"
+            )
+
+            if result.returncode == 0:
+                log_info_pair(
+                    "✓ Dependencies updated successfully",
+                    "✓ 依赖更新成功",
+                )
+                return True
+            else:
+                log_info_pair(
+                    f"Warning: Failed to update dependencies: {result.stderr}",
+                    f"警告: 更新依赖失败: {result.stderr}",
+                )
+                return False
+        except Exception as e:
+            log_info_pair(
+                f"Warning: Failed to sync environment: {e}",
+                f"警告: 同步环境失败: {e}",
+            )
+            return False