py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/file_operations.py

@@ -0,0 +1,506 @@
+"""File operations utilities for WL Commands."""
+
+import fnmatch
+import os
+import re
+import shutil
+import time
+from pathlib import Path
+from typing import cast
+
+from .platform_adapter import PlatformAdapter
+
+WINDOWS_DRIVE_PATTERN = re.compile(r"^[a-zA-Z]:[\\/]")
+
+
+class FileOperationResult:
+    """Result of a file operation."""
+
+    def __init__(
+        self, success: bool, message: str = "", files_affected: list[str] | None = None
+    ):
+        self.success = success
+        self.message = message
+        self.files_affected = files_affected or []
+
+
+class FileOperationsCache:
+    """Cache for file operations to avoid redundant operations."""
+
+    def __init__(self):
+        self._existence_cache: dict[str, bool] = {}
+        self._directory_contents_cache: dict[str, list[str]] = {}
+
+    def clear(self) -> None:
+        """Clear the cache."""
+        self._existence_cache.clear()
+        self._directory_contents_cache.clear()
+
+
+class FileOperations:
+    """Unified file operations utility class."""
+
+    def __init__(self):
+        self.cache = FileOperationsCache()
+        self.is_windows: bool = PlatformAdapter.is_windows()
+
+    def _handle_windows_operation(self, operation, *args, **kwargs):
+        """
+        Handle Windows file locking issues by retrying operations.
+
+        Args:
+            operation: The operation to perform
+            *args: Arguments for the operation
+            **kwargs: Keyword arguments for the operation
+
+        Returns:
+            The result of the operation
+        """
+        if not self.is_windows:
+            return operation(*args, **kwargs)
+
+        max_attempts = 3
+        for attempt in range(max_attempts):
+            try:
+                return operation(*args, **kwargs)
+            except PermissionError:
+                if attempt < max_attempts - 1:
+                    time.sleep(0.5)
+                    continue
+                else:
+                    raise
+
+    def exists(self, path: str | Path) -> bool:
+        """
+        Check if a path exists.
+
+        Args:
+            path: Path to check
+
+        Returns:
+            True if path exists, False otherwise
+        """
+        if path is None:
+            return False
+
+        if not isinstance(path, str | Path):
+            raise TypeError(f"Expected str or Path, got {type(path).__name__}")
+
+        path_str = str(path)
+
+        # Check for Windows-style absolute paths (drive letter + colon) on non-Windows platforms
+        if not self.is_windows and WINDOWS_DRIVE_PATTERN.match(path_str):
+            # On non-Windows platforms, Windows drive paths don't exist
+            return False
+
+        # Convert Windows-style backslashes to platform-specific separators
+        path_str = path_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in path_str:
+            raise ValueError("Path traversal detected")
+
+        if path_str in self.cache._existence_cache:
+            return cast("bool", self.cache._existence_cache[path_str])
+
+        result = Path(path_str).exists()
+        self.cache._existence_cache[path_str] = result
+        return result
+
+    def get_files_in_directory(
+        self, directory: str | Path, pattern: str = "*", recursive: bool = True
+    ) -> list[Path]:
+        """
+        Get all files in a directory matching a pattern.
+
+        Args:
+            directory: Directory to search
+            pattern: File pattern to match (e.g., "*.py")
+            recursive: Whether to search recursively
+
+        Returns:
+            List of matching files
+        """
+        if directory is None:
+            return []
+
+        if not isinstance(directory, str | Path):
+            raise TypeError(f"Expected str or Path, got {type(directory).__name__}")
+
+        directory_str = str(directory)
+
+        # Convert Windows-style backslashes to platform-specific separators
+        directory_str = directory_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in directory_str:
+            raise ValueError("Path traversal detected")
+
+        cache_key = f"{directory_str}:{pattern}:{recursive}"
+
+        if cache_key in self.cache._directory_contents_cache:
+            # Convert cached strings back to Path objects
+            return [Path(p) for p in self.cache._directory_contents_cache[cache_key]]
+
+        dir_path = Path(directory_str)
+        if not self.exists(dir_path):
+            self.cache._directory_contents_cache[cache_key] = []
+            return []
+
+        if recursive:
+            files = list(dir_path.rglob(pattern))
+        else:
+            files = list(dir_path.glob(pattern))
+
+        # Cache the result as strings
+        file_strings = [str(f) for f in files]
+        self.cache._directory_contents_cache[cache_key] = file_strings
+
+        return files
+
+    def copy_file(self, src: str | Path, dst: str | Path) -> FileOperationResult:
+        """
+        Copy a file from src to dst.
+
+        Args:
+            src: Source file path
+            dst: Destination file path
+
+        Returns:
+            FileOperationResult indicating success or failure
+
+        Raises:
+            TypeError: If src or dst is not a str or Path
+            ValueError: If src or dst is None or contains path traversal
+        """
+        # Validate input parameters
+        if src is None or dst is None:
+            raise ValueError("Source or destination path cannot be None")
+
+        if not isinstance(src, str | Path):
+            raise TypeError(
+                f"Expected str or Path for source, got {type(src).__name__}"
+            )
+
+        if not isinstance(dst, str | Path):
+            raise TypeError(
+                f"Expected str or Path for destination, got {type(dst).__name__}"
+            )
+
+        # Convert Windows-style backslashes to platform-specific separators for src
+        src_str = str(src)
+        src_str = src_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in src_str:
+            raise ValueError("Path traversal detected in source path")
+
+        src_path = Path(src_str)
+
+        # Convert Windows-style backslashes to platform-specific separators for dst
+        dst_str = str(dst)
+        dst_str = dst_str.replace("\\", os.path.sep)
+
+        # Check for Windows-style absolute paths (drive letter + colon) on non-Windows platforms
+        if not self.is_windows and WINDOWS_DRIVE_PATTERN.match(str(dst)):
+            # On non-Windows platforms, Windows drive paths are not supported
+            return FileOperationResult(
+                False, f"Windows drive paths not supported on this platform: {dst}"
+            )
+
+        # Prevent path traversal
+        if ".." in dst_str:
+            raise ValueError("Path traversal detected in destination path")
+
+        dst_path = Path(dst_str)
+
+        try:
+            if not self.exists(src_path):
+                return FileOperationResult(
+                    False, f"Source file does not exist: {src_path}"
+                )
+
+            # Create parent directories if they don't exist
+            dst_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Handle Windows file locking issues
+            self._handle_windows_operation(shutil.copy2, src_path, dst_path)
+
+            # Update cache
+            self._update_cache_for_file_copy(dst_path)
+
+            return FileOperationResult(
+                True, f"Successfully copied {src_path} to {dst_path}", [str(dst_path)]
+            )
+        except Exception as e:
+            return FileOperationResult(
+                False, f"Failed to copy file from {src} to {dst}: {str(e)}"
+            )
+
+    def _should_exclude(
+        self, item: Path, src_path: Path, exclude_patterns: list[str]
+    ) -> bool:
+        """Check if an item should be excluded based on patterns.
+
+        Args:
+            item: Path to check
+            src_path: Source directory path
+            exclude_patterns: List of patterns to exclude
+
+        Returns:
+            True if item should be excluded, False otherwise
+        """
+        for pattern in exclude_patterns:
+            if fnmatch.fnmatch(item.name, pattern) or fnmatch.fnmatch(
+                str(item.relative_to(src_path)), pattern
+            ):
+                return True
+        return False
+
+    def _clear_destination_cache(self, dst_str: str) -> None:
+        """Clear cache entries related to the destination directory.
+
+        Args:
+            dst_str: Destination directory path as string
+        """
+        # Clear existence cache
+        if dst_str in self.cache._existence_cache:
+            del self.cache._existence_cache[dst_str]
+
+        # Clear directory contents cache
+        cache_keys_to_remove = []
+        for key in self.cache._directory_contents_cache:
+            if key.startswith(dst_str):
+                cache_keys_to_remove.append(key)
+
+        for key in cache_keys_to_remove:
+            if key in self.cache._directory_contents_cache:
+                del self.cache._directory_contents_cache[key]
+
+    def _update_cache_for_file_copy(self, dst_path: Path) -> None:
+        """Update cache after file copy operation.
+
+        Args:
+            dst_path: Destination file path
+        """
+        dst_str = str(dst_path)
+        # Update cache for destination file
+        if dst_str in self.cache._existence_cache:
+            del self.cache._existence_cache[dst_str]
+
+        # Clear directory contents cache for parent directory
+        parent_dir = str(dst_path.parent)
+        self._clear_destination_cache(parent_dir)
+
+    def _copy_item(
+        self,
+        item: Path,
+        src_path: Path,
+        dst_path: Path,
+        exclude_patterns: list[str] | None,
+    ) -> list[str]:
+        """Copy a single item (file or directory).
+
+        Args:
+            item: Item to copy
+            src_path: Source directory path
+            dst_path: Destination directory path
+            exclude_patterns: List of patterns to exclude
+
+        Returns:
+            List of copied files
+        """
+        copied_files: list[str] = []
+
+        # Skip excluded patterns
+        if exclude_patterns and self._should_exclude(item, src_path, exclude_patterns):
+            return copied_files
+
+        relative_path = item.relative_to(src_path)
+        dst_item = dst_path / relative_path
+
+        if item.is_file():
+            dst_item.parent.mkdir(parents=True, exist_ok=True)
+            # Handle Windows file locking issues
+            self._handle_windows_operation(shutil.copy2, item, dst_item)
+            copied_files.append(str(dst_item))
+        elif item.is_dir():
+            dst_item.mkdir(parents=True, exist_ok=True)
+
+        return copied_files
+
+    def copy_directory(
+        self,
+        src: str | Path,
+        dst: str | Path,
+        exclude_patterns: list[str] | None = None,
+    ) -> FileOperationResult:
+        """
+        Copy a directory from src to dst.
+
+        Args:
+            src: Source directory path
+            dst: Destination directory path
+            exclude_patterns: List of patterns to exclude (e.g., ["*.tmp", "__pycache__"])
+
+        Returns:
+            FileOperationResult indicating success or failure
+
+        Raises:
+            TypeError: If src or dst is not a str or Path
+            ValueError: If src or dst is None or contains path traversal
+        """
+        # Validate input parameters
+        if src is None or dst is None:
+            raise ValueError("Source or destination path cannot be None")
+
+        if not isinstance(src, str | Path):
+            raise TypeError(
+                f"Expected str or Path for source, got {type(src).__name__}"
+            )
+
+        if not isinstance(dst, str | Path):
+            raise TypeError(
+                f"Expected str or Path for destination, got {type(dst).__name__}"
+            )
+
+        # Convert Windows-style backslashes to platform-specific separators for src
+        src_str = str(src)
+        src_str = src_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in src_str:
+            raise ValueError("Path traversal detected in source path")
+
+        src_path = Path(src_str)
+
+        # Convert Windows-style backslashes to platform-specific separators for dst
+        dst_str = str(dst)
+        dst_str = dst_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in dst_str:
+            raise ValueError("Path traversal detected in destination path")
+
+        dst_path = Path(dst_str)
+
+        try:
+            if not self.exists(src_path):
+                return FileOperationResult(
+                    False, f"Source directory does not exist: {src_path}"
+                )
+
+            if not src_path.is_dir():
+                return FileOperationResult(
+                    False, f"Source path is not a directory: {src_path}"
+                )
+
+            # Create destination directory
+            dst_path.mkdir(parents=True, exist_ok=True)
+
+            copied_files = []
+
+            for item in src_path.rglob("*"):
+                copied_files.extend(
+                    self._copy_item(item, src_path, dst_path, exclude_patterns)
+                )
+
+            # Clear relevant cache entries
+            dst_str = str(dst_path)
+            self._clear_destination_cache(dst_str)
+
+            return FileOperationResult(
+                True,
+                f"Successfully copied directory {src_path} to {dst_path}",
+                copied_files,
+            )
+        except Exception as e:
+            return FileOperationResult(
+                False, f"Failed to copy directory from {src} to {dst}: {str(e)}"
+            )
+
+    def remove_directory(self, directory: str | Path) -> FileOperationResult:
+        """
+        Remove a directory and all its contents.
+
+        Args:
+            directory: Directory to remove
+
+        Returns:
+            FileOperationResult indicating success or failure
+
+        Raises:
+            TypeError: If directory is not a str or Path
+            ValueError: If directory is None or contains path traversal
+        """
+        # Validate input parameters
+        if directory is None:
+            raise ValueError("Directory path cannot be None")
+
+        if not isinstance(directory, str | Path):
+            raise TypeError(f"Expected str or Path, got {type(directory).__name__}")
+
+        # Convert Windows-style backslashes to platform-specific separators
+        dir_str = str(directory)
+        dir_str = dir_str.replace("\\", os.path.sep)
+
+        # Prevent path traversal
+        if ".." in dir_str:
+            raise ValueError("Path traversal detected")
+
+        dir_path = Path(dir_str)
+
+        try:
+            if not self.exists(dir_path):
+                return FileOperationResult(
+                    True, f"Directory does not exist: {dir_path}"
+                )
+
+            if not dir_path.is_dir():
+                return FileOperationResult(
+                    False, f"Path is not a directory: {dir_path}"
+                )
+
+            # Handle Windows file locking issues
+            self._handle_windows_operation(shutil.rmtree, dir_path)
+
+            # Clear relevant cache entries
+            dir_str = str(dir_path)
+            if dir_str in self.cache._existence_cache:
+                del self.cache._existence_cache[dir_str]
+
+            # Clear directory contents cache entries that might be affected
+            cache_keys_to_remove = []
+            for key in self.cache._directory_contents_cache:
+                if key.startswith(dir_str):
+                    cache_keys_to_remove.append(key)
+
+            for key in cache_keys_to_remove:
+                if key in self.cache._directory_contents_cache:
+                    del self.cache._directory_contents_cache[key]
+
+            return FileOperationResult(
+                True, f"Successfully removed directory {dir_path}"
+            )
+        except Exception as e:
+            return FileOperationResult(
+                False, f"Failed to remove directory {directory}: {str(e)}"
+            )
+
+    def clear_cache(self) -> None:
+        """Clear the file operations cache."""
+        self.cache.clear()
+
+
+# Global instance
+_file_operations = FileOperations()
+
+
+def get_file_operations() -> FileOperations:
+    """
+    Get the global file operations instance.
+
+    Returns:
+        The global file operations instance
+    """
+    return _file_operations

wl_cli/utils/language_utils.py

@@ -0,0 +1,122 @@
+"""Language detection utilities for WL Commands."""
+
+import locale
+import os
+
+# Cache for system language detection
+_system_chinese_cache = None
+
+
+def _is_system_chinese() -> bool:
+    """
+    Check if the system language is Chinese.
+
+    Returns:
+        bool: True if system language is Chinese, False otherwise
+    """
+    global _system_chinese_cache
+
+    # Use cached value if available
+    if _system_chinese_cache is not None:
+        return _system_chinese_cache
+
+    try:
+        # Try different locale-related environment variables
+        lang = (
+            os.environ.get("LANG", "")
+            or os.environ.get("LANGUAGE", "")
+            or os.environ.get("LC_ALL", "")
+            or os.environ.get("LC_MESSAGES", "")
+        )
+
+        # Fall back to locale.getlocale() if environment variables don't provide language info
+        if not lang:
+            try:
+                locale_value = locale.getlocale()[0]  # Get language code from locale
+                if locale_value:
+                    lang = locale_value
+            except (ValueError, TypeError):
+                # If getlocale() fails, use empty string
+                pass
+
+        # Check if any of the locale identifiers contain Chinese language codes
+        # 更宽松的检测逻辑，确保能正确检测中文
+        result = any(chinese_lang in lang.lower() for chinese_lang in ["zh", "chinese"])
+
+        # 调试信息 (已注释掉，避免影响测试)
+        # if lang:
+        #     print(f"检测到语言设置: {lang}, 结果: {result}")
+
+        # Cache the result
+        _system_chinese_cache = result
+        return result
+    except (OSError, KeyError, ValueError):
+        # If we can't determine the language, default to English
+        _system_chinese_cache = False
+        return False
+
+
+# Cache for language setting
+_language_setting_cache = None
+
+
+def reset_language_caches() -> None:
+    """重置语言检测缓存，用于测试
+
+    This function resets both the system Chinese language cache and the language setting cache.
+    It's primarily used for testing purposes to ensure clean state between tests.
+    """
+    global _system_chinese_cache, _language_setting_cache
+    _system_chinese_cache = None
+    _language_setting_cache = None
+
+
+def _should_display_language(lang: str) -> bool:
+    """
+    Check if message in specified language should be displayed.
+
+    Args:
+        lang (str): Language of the message ("en" or "zh")
+
+    Returns:
+        bool: True if message should be displayed
+    """
+    global _language_setting_cache
+
+    # Use cached language setting if available
+    if _language_setting_cache is None:
+        try:
+            # Check environment variable first (highest priority)
+            if "WL_LANGUAGE" in os.environ:
+                _language_setting_cache = os.environ["WL_LANGUAGE"]
+            else:
+                # Try to import config module
+                try:
+                    from .config import get_config
+
+                    _language_setting_cache = get_config("language", "auto")
+                except ImportError:
+                    # Fall back to auto detection
+                    _language_setting_cache = "auto"
+        except (ImportError, KeyError):
+            # Default to auto if config is not available
+            _language_setting_cache = "auto"
+
+    # Use cached language setting
+    language_setting = _language_setting_cache
+
+    # If language is set to auto, display based on system language
+    if language_setting == "auto":
+        # If system language is Chinese, only show Chinese messages
+        # Otherwise, show English messages
+        is_system_chinese = _is_system_chinese()
+        return (lang == "zh" and is_system_chinese) or (
+            lang == "en" and not is_system_chinese
+        )
+
+    # If language is set to specific language, only display that language
+    if language_setting in ["en", "zh"]:
+        return language_setting == lang
+    else:
+        # Default to showing English for invalid language settings
+        return lang == "en"