pysfi 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

sfi/pylibpack/pylibpack.py

@@ -10,23 +10,23 @@ This module provides functionality to:
 from __future__ import annotations
 
 import argparse
+import atexit
 import json
 import logging
-import platform
 import re
 import shutil
 import subprocess
-import sys
 import tarfile
 import tempfile
 import time
 import zipfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
+from functools import cached_property
 from pathlib import Path
-from typing import Any, Pattern
+from typing import Any, ClassVar, Final, Pattern
 
-from sfi.pyprojectparse.pyprojectparse import Project, Solution
+from sfi.pyprojectparse.pyprojectparse import Dependency, Project, Solution
 
 logging.basicConfig(
     level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
@@ -38,9 +38,23 @@ __build__ = "20260120"
 
 DEFAULT_CACHE_DIR = Path.home() / ".pysfi" / ".cache" / "python-libs"
 
-MAX_DEPTH = 50  # Maximum recursion depth to prevent infinite loops
+MAX_DEPTH: Final[int] = 50  # Maximum recursion depth to prevent infinite loops
 
-PYPI_MIRRORS = {
+# Archive format constants
+SUPPORTED_ARCHIVE_FORMATS: Final[tuple[str, ...]] = (
+    "zip",
+    "tar",
+    "gztar",
+    "bztar",
+    "xztar",
+)
+
+# Default configuration constants
+DEFAULT_MAX_WORKERS: Final[int] = 4
+DEFAULT_MIRROR: Final[str] = "aliyun"
+DEFAULT_OPTIMIZE: Final[bool] = True
+
+PYPI_MIRRORS: Final[dict[str, str]] = {
     "pypi": "https://pypi.org/simple",
     "tsinghua": "https://pypi.tuna.tsinghua.edu.cn/simple",
     "aliyun": "https://mirrors.aliyun.com/pypi/simple/",
@@ -50,24 +64,74 @@ PYPI_MIRRORS = {
 }
 
 
-@dataclass(frozen=True)
-class Dependency:
-    """Represents a Python package dependency."""
+CONFIG_FILE = Path.home() / ".pysfi" / "pylibpack.json"
 
-    name: str
-    version: str | None = None
-    extras: set[str] = field(default_factory=set)
-    requires: set[str] = field(default_factory=set)
 
-    def __post_init__(self):
-        """Normalize package name after initialization."""
-        object.__setattr__(self, "name", normalize_package_name(self.name))
+@dataclass
+class PyLibPackerConfig:
+    """Configuration for PyLibPack with persistent settings."""
+
+    cache_dir: Path | None = None
+    mirror: str = DEFAULT_MIRROR
+    optimize: bool = DEFAULT_OPTIMIZE
+    max_workers: int = DEFAULT_MAX_WORKERS
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        mirror: str = DEFAULT_MIRROR,
+        optimize: bool = DEFAULT_OPTIMIZE,
+        max_workers: int = DEFAULT_MAX_WORKERS,
+    ):
+        # Track which parameters were explicitly provided
+        self._explicitly_set = {}
+
+        if cache_dir is not None:
+            self._explicitly_set["cache_dir"] = True
+        if mirror != DEFAULT_MIRROR:
+            self._explicitly_set["mirror"] = True
+        if optimize != DEFAULT_OPTIMIZE:
+            self._explicitly_set["optimize"] = True
+        if max_workers != DEFAULT_MAX_WORKERS:
+            self._explicitly_set["max_workers"] = True
+
+        # Set the values
+        self.cache_dir = cache_dir
+        self.mirror = mirror
+        self.optimize = optimize
+        self.max_workers = max_workers
+
+        # Apply defaults for unset values
+        if self.cache_dir is None:
+            self.cache_dir = DEFAULT_CACHE_DIR
 
-    def __str__(self) -> str:
-        """String representation of dependency."""
-        if self.extras:
-            return f"{self.name}[{','.join(sorted(self.extras))}]{self.version or ''}"
-        return f"{self.name}{self.version or ''}"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load configuration from file if it exists
+        if CONFIG_FILE.exists():
+            try:
+                config_data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+                # Update configuration items, but only for those not explicitly set
+                for key, value in config_data.items():
+                    if (
+                        hasattr(self, key)
+                        and isinstance(value, type(getattr(self, key)))
+                        and key not in self._explicitly_set
+                    ):
+                        setattr(self, key, value)
+            except (json.JSONDecodeError, TypeError, AttributeError) as e:
+                logger.warning(f"Could not load config from {CONFIG_FILE}: {e}")
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        config_dict = {
+            "cache_dir": str(self.cache_dir),
+            "mirror": self.mirror,
+            "optimize": self.optimize,
+            "max_workers": self.max_workers,
+        }
+        CONFIG_FILE.write_text(json.dumps(config_dict, indent=4), encoding="utf-8")
 
 
 @dataclass
@@ -92,20 +156,6 @@ class PackResult:
     failed: int
     packages_dir: str
     extracted_packages: list[str] = field(default_factory=list)
-    message: str = ""
-
-
-@dataclass
-class BatchPackResult:
-    """Result of packing multiple projects."""
-
-    success: bool
-    total: int
-    successful: int
-    failed: int
-    failed_projects: list[str] = field(default_factory=list)
-    output_dir: str = ""
-    total_time: float = 0.0
 
 
 @dataclass
@@ -154,7 +204,7 @@ class OptimizationRule:
     exclude_patterns: list[str] = field(default_factory=list)
     include_patterns: list[str] = field(default_factory=list)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         """Compile regex patterns after initialization."""
         self.exclude_compiled: list[Pattern] = [
             re.compile(p) for p in self.exclude_patterns
@@ -164,6 +214,7 @@ class OptimizationRule:
         ]
 
 
+@dataclass(frozen=False)
 class SelectiveExtractionStrategy:
     """Optimization strategy that applies inclusion/exclusion rules to specific libraries.
 
@@ -174,7 +225,7 @@ class SelectiveExtractionStrategy:
     """
 
     # Universal exclusion patterns - applied to all libraries
-    UNIVERSAL_EXCLUDE_PATTERNS = frozenset({
+    UNIVERSAL_EXCLUDE_PATTERNS: ClassVar[frozenset[str]] = frozenset({
         "doc",
         "docs",
         "test",
@@ -223,8 +274,12 @@ class SelectiveExtractionStrategy:
             for pattern in self.UNIVERSAL_EXCLUDE_PATTERNS
         ]
 
-    def _setup_default_rules(self):
-        """Setup default optimization rules for common libraries."""
+    def _setup_default_rules(self) -> None:
+        """Setup default optimization rules for common libraries.
+
+        This method loads JSON rule files from the rules directory and
+        creates OptimizationRule objects for common libraries.
+        """
         # Get the rules directory
         rules_dir = Path(__file__).parent / "rules"
 
@@ -359,12 +414,13 @@ def should_skip_dependency(req_name: str, has_extras: bool = False) -> bool:
     Returns:
         True if should skip, False otherwise
     """
-    req_lower = req_name.lower()
-
     # Skip extras
     if has_extras:
         return True
 
+    req_lower = req_name.lower()
+    normalized_req = req_lower.replace("-", "_")
+
     # Skip dev/test/docs/lint/example patterns
     if any(keyword in req_lower for keyword in DEV_PATTERNS):
         return True
@@ -374,23 +430,141 @@ def should_skip_dependency(req_name: str, has_extras: bool = False) -> bool:
         return True
 
     # Skip common dev tools
-    return req_lower.replace("-", "_") in DEV_TOOLS
+    return normalized_req in DEV_TOOLS
 
 
+@dataclass(frozen=False)
 class LibraryCache:
     """Manage local cache for Python packages."""
 
-    def __init__(self, cache_dir: Path | None = None):
-        """Initialize cache manager.
+    cache_dir: Path = field(default_factory=lambda: DEFAULT_CACHE_DIR)
+    _dependencies_cache: dict[Path, set[str]] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    @cached_property
+    def metadata_file(self) -> Path:
+        return self.cache_dir / "metadata.json"
+
+    @cached_property
+    def wheel_files(self) -> list[Path]:
+        return list(self.cache_dir.glob("*.whl"))
+
+    @cached_property
+    def sdist_files(self) -> list[Path]:
+        return list(self.cache_dir.glob("*.tar.gz")) + list(
+            self.cache_dir.glob("*.zip")
+        )
+
+    def collect_dependencies_from_list(self, dependency_list: list[str]) -> set[str]:
+        """Recursively collect all dependencies from package files (wheel or sdist).
 
         Args:
-            cache_dir: Cache directory path (default: ~/.pysfi/.cache/pylibpack)
+            dependency_list: List of root package names to start from
+
+        Returns:
+            Set of all required package names (normalized)
         """
-        self.cache_dir = cache_dir or DEFAULT_CACHE_DIR
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.metadata_file = self.cache_dir / "metadata.json"
-        # In-memory cache for extracted dependencies to avoid repeated IO
-        self._dependencies_cache: dict[Path, set[str]] = {}
+        all_packages: set[str] = set()
+        visited: set[str] = set()
+        visit_stack: dict[str, int] = {}  # Track visit depth for cycle detection
+
+        def visit(pkg_name: str, level: int = 0) -> None:
+            """Visit a package and collect its dependencies."""
+            # Normalize package name for consistency
+            normalized_pkg_name = pkg_name.lower().replace("-", "_")
+
+            # Check for cycles
+            if normalized_pkg_name in visit_stack:
+                logger.warning(
+                    f"Potential circular dependency detected: {normalized_pkg_name} (current depth: {level}, "
+                    f"previous depth: {visit_stack[normalized_pkg_name]})"
+                )
+                return
+
+            # Check depth limit
+            if level > MAX_DEPTH:
+                logger.warning(
+                    f"Maximum dependency depth ({MAX_DEPTH}) reached for {normalized_pkg_name}, stopping recursion"
+                )
+                return
+
+            # Skip if already visited
+            if normalized_pkg_name in visited:
+                return
+
+            # Mark as visited and track depth
+            visited.add(normalized_pkg_name)
+            visit_stack[normalized_pkg_name] = level
+            all_packages.add(normalized_pkg_name)
+
+            # Process dependencies if package exists in map
+            package_path = self.package_map.get(normalized_pkg_name)
+            if package_path:
+                deps = self._extract_dependencies_from_wheel(package_path)
+                logger.debug(f"{'  ' * level}{normalized_pkg_name} -> {deps}")
+                for dep in deps:
+                    visit(dep, level + 1)
+
+            # Remove from stack when done
+            visit_stack.pop(normalized_pkg_name, None)
+
+        for pkg_name in dependency_list:
+            visit(pkg_name)
+
+        logger.info(f"Collected {len(all_packages)} packages: {all_packages}")
+        return all_packages
+
+    @cached_property
+    def package_map(self) -> dict[str, Path]:
+        """Create a mapping of package names to their file paths with improved efficiency."""
+        packages: dict[str, Path] = {}
+
+        # Process wheel files first (they take precedence)
+        for wheel_file in self.wheel_files:
+            pkg_name = self._extract_package_name_from_wheel(wheel_file)
+            if pkg_name:
+                normalized_pkg_name = normalize_package_name(pkg_name)
+                packages[normalized_pkg_name] = wheel_file
+
+        # Add sdist files only if the package isn't already in the map
+        for sdist_file in self.sdist_files:
+            pkg_name = self._extract_package_name_from_sdist(sdist_file)
+            if pkg_name:
+                normalized_pkg_name = normalize_package_name(pkg_name)
+                if normalized_pkg_name not in packages:
+                    packages[normalized_pkg_name] = sdist_file
+
+        return packages
+
+    @cached_property
+    def cache_size(self) -> int:
+        """Calculate total size of cache in bytes."""
+        if not self.cache_dir.exists():
+            return 0
+
+        # Use generator expression for memory efficiency
+        return sum(
+            file_path.stat().st_size
+            for file_path in self.cache_dir.rglob("*")
+            if file_path.is_file()
+        )
+
+    @cached_property
+    def package_count(self) -> int:
+        """Get the count of packages in cache."""
+        return len(self.package_map)
+
+    @cached_property
+    def cache_stats(self) -> dict[str, int]:
+        """Get detailed cache statistics."""
+        return {
+            "total_packages": self.package_count,
+            "wheel_count": len(self.wheel_files),
+            "sdist_count": len(self.sdist_files),
+            "cache_size_bytes": self.cache_size,
+        }
 
     def get_package_path(
         self, package_name: str, version: str | None = None
@@ -404,29 +578,31 @@ class LibraryCache:
         Returns:
             Path to cached package or None
         """
+        normalized_name = normalize_package_name(package_name)
+
         # First try filesystem lookup for wheel files (works even if metadata is missing)
         for whl_file in self.cache_dir.glob("*.whl"):
             parsed_name = self._extract_package_name_from_wheel(whl_file)
-            if parsed_name == package_name:
+            if parsed_name == normalized_name:
                 logger.debug(f"Cache hit (filesystem wheel): {package_name}")
                 return whl_file
 
         # Try filesystem lookup for sdist files (.tar.gz, .zip)
         for sdist_file in self.cache_dir.glob("*.tar.gz"):
             parsed_name = self._extract_package_name_from_sdist(sdist_file)
-            if parsed_name == package_name:
+            if parsed_name == normalized_name:
                 logger.debug(f"Cache hit (filesystem sdist): {package_name}")
                 return sdist_file
         for sdist_file in self.cache_dir.glob("*.zip"):
             parsed_name = self._extract_package_name_from_sdist(sdist_file)
-            if parsed_name == package_name:
+            if parsed_name == normalized_name:
                 logger.debug(f"Cache hit (filesystem sdist): {package_name}")
                 return sdist_file
 
         # Fallback to metadata lookup
         metadata = self._load_metadata()
         for info in metadata.values():
-            if info["name"] == package_name and (
+            if info["name"] == normalized_name and (
                 version is None or info.get("version") == version
             ):
                 path = self.cache_dir / info["path"]
@@ -499,7 +675,7 @@ class LibraryCache:
         """Extract dependencies from wheel METADATA file with caching.
 
         Args:
-            wheel_file: Path to wheel file
+            wheel_file: Path to wheel or sdist file
 
         Returns:
             Set of package names (normalized)
@@ -514,47 +690,26 @@ class LibraryCache:
             self._dependencies_cache[wheel_file] = dependencies
             return dependencies
 
-        try:
-            import re
-            import zipfile
+        # Early return if wheel file doesn't exist
+        if not wheel_file.exists():
+            logger.warning(f"Wheel file does not exist: {wheel_file}")
+            self._dependencies_cache[wheel_file] = set()
+            return set()
 
-            dependencies: set[str] = set()
+        try:
             with zipfile.ZipFile(wheel_file, "r") as zf:
+                # Find metadata file
                 metadata_files = [
                     name for name in zf.namelist() if name.endswith("METADATA")
                 ]
-                if not metadata_files:
-                    self._dependencies_cache[wheel_file] = dependencies
-                    return dependencies
-
-                metadata_content = zf.read(metadata_files[0]).decode(
-                    "utf-8", errors="ignore"
-                )
-
-                # Parse dependencies from METADATA
-                for line in metadata_content.splitlines():
-                    if line.startswith("Requires-Dist:"):
-                        dep_str = line.split(":", 1)[1].strip()
 
-                        # Skip extras dependencies
-                        if re.search(
-                            r'extra\s*==\s*["\']?([^"\';\s]+)["\']?',
-                            dep_str,
-                            re.IGNORECASE,
-                        ):
-                            logger.debug(f"Skipping extra dependency: {dep_str}")
-                            continue
-
-                        try:
-                            from packaging.requirements import Requirement
-
-                            req = Requirement(dep_str)
-                            if not should_skip_dependency(req.name, bool(req.extras)):
-                                dep_name = normalize_package_name(req.name)
-                                dependencies.add(dep_name)
-                                logger.debug(f"Found core dependency: {dep_name}")
-                        except Exception:
-                            pass
+                if not metadata_files:
+                    dependencies = set()
+                else:
+                    metadata_content = zf.read(metadata_files[0]).decode(
+                        "utf-8", errors="ignore"
+                    )
+                    dependencies = self._parse_metadata_content(metadata_content)
 
             # Cache the result
             self._dependencies_cache[wheel_file] = dependencies
@@ -583,9 +738,7 @@ class LibraryCache:
                 with tarfile.open(sdist_file, "r:gz") as tf:
                     for member in tf.getmembers():
                         # Look for PKG-INFO or METADATA file in the root of the package
-                        if member.name.endswith("PKG-INFO") or member.name.endswith(
-                            "METADATA"
-                        ):
+                        if member.name.endswith(("PKG-INFO", "METADATA")):
                             # Only use PKG-INFO/METADATA files in the root directory
                             # Count the number of slashes in the path
                             path_parts = member.name.split("/")
@@ -610,7 +763,7 @@ class LibraryCache:
                 with zipfile.ZipFile(sdist_file, "r") as zf:
                     for name in zf.namelist():
                         # Look for PKG-INFO or METADATA file in the root of the package
-                        if name.endswith("PKG-INFO") or name.endswith("METADATA"):
+                        if name.endswith(("PKG-INFO", "METADATA")):
                             path_parts = name.split("/")
                             if len(path_parts) == 2 or (
                                 len(path_parts) == 3
@@ -643,8 +796,6 @@ class LibraryCache:
         Returns:
             Set of package names (normalized)
         """
-        import re
-
         dependencies: set[str] = set()
         try:
             for line in metadata_content.splitlines():
@@ -680,8 +831,6 @@ class LibraryCache:
         Returns:
             Set containing the normalized package name, or empty set if should skip
         """
-        import re
-
         try:
             # Skip extras dependencies
             if re.search(
@@ -763,6 +912,14 @@ class LibraryCache:
         with open(self.metadata_file, "w", encoding="utf-8") as f:
             json.dump(metadata, f, indent=2)
 
+    @staticmethod
+    def _should_skip_dist_info(file_path: Path) -> bool:
+        """Check if the file path should be skipped because it's a dist-info directory."""
+        if file_path.name.endswith(".dist-info"):
+            return True
+        # Check if any parent directory ends with .dist-info
+        return any(part.endswith(".dist-info") for part in file_path.parts)
+
     def clear_cache(self) -> None:
         """Clear all cached packages."""
         if self.cache_dir.exists():
@@ -772,31 +929,21 @@ class LibraryCache:
         logger.info("Cache cleared")
 
 
+@dataclass(frozen=True)
 class LibraryDownloader:
     """Download Python packages from PyPI."""
 
-    def __init__(
-        self,
-        cache: LibraryCache,
-        python_version: str | None = None,
-        mirror: str = "pypi",
-    ):
-        """Initialize downloader.
+    parent: PyLibPacker
+    cache: LibraryCache
+    _mirror: str = "pypi"
 
-        Args:
-            cache: Cache manager
-            python_version: Target Python version for platform-specific packages
-            mirror: PyPI mirror source (pypi, tsinghua, aliyun, ustc, douban, tencent)
-        """
-        self.cache = cache
-        self.python_version = (
-            python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
-        )
-        self.platform_name = (
-            platform.system().lower() + "_" + platform.machine().lower()
-        )
-        self.mirror_url = PYPI_MIRRORS.get(mirror, PYPI_MIRRORS["pypi"])
-        self.pip_executable = self._find_pip_executable()
+    @cached_property
+    def mirror_url(self) -> str:
+        return PYPI_MIRRORS.get(self._mirror, PYPI_MIRRORS["pypi"])
+
+    @cached_property
+    def pip_executable(self) -> str | None:
+        return self._find_pip_executable()
 
     @staticmethod
     def _find_pip_executable() -> str | None:
@@ -808,7 +955,7 @@ class LibraryDownloader:
 
         Args:
             dep: Dependency to download
-            dest_dir: Destination directory
+            dest_dir: Destination directory (typically cache_dir)
 
         Returns:
             Path to downloaded package file (wheel or sdist) or None
@@ -865,54 +1012,45 @@ class LibraryDownloader:
 
         return None
 
-    def download_packages(
-        self,
-        dependencies: list[Dependency],
-        dest_dir: Path,
-        max_workers: int = 4,
-    ) -> DownloadResult:
+    def download_packages(self, project: Project) -> DownloadResult:
         """Download multiple packages concurrently.
 
         Args:
-            dependencies: List of dependencies to download
-            dest_dir: Destination directory
-            max_workers: Maximum concurrent downloads
+            project: Project containing dependencies to download
 
         Returns:
             DownloadResult containing download statistics
         """
-        dest_dir.mkdir(parents=True, exist_ok=True)
-
-        # Use list of tuples for thread-safe result collection
-        # Tuple format: (package_name, success_flag)
         results_list: list[tuple[str, bool]] = []
         cached_count = 0
         cached_packages: set[str] = set()  # Track cached package names efficiently
 
+        dependencies = project.converted_dependencies
         logger.info(f"Total direct dependencies: {len(dependencies)}")
         logger.info(f"Using mirror: {self.mirror_url}")
 
         # Check cache and mark cached packages (single-threaded, safe)
         for dep in dependencies:
             if self.cache.get_package_path(dep.name, dep.version):
-                normalized_dep_name = normalize_package_name(dep.name)
-                results_list.append((normalized_dep_name, True))
-                cached_packages.add(normalized_dep_name)
+                results_list.append((dep.name, True))
+                cached_packages.add(dep.name)
                 cached_count += 1
                 logger.info(f"Using cached package: {dep}")
 
         # Download remaining packages concurrently
         remaining_deps = [
-            dep
-            for dep in dependencies
-            if normalize_package_name(dep.name) not in cached_packages
+            dep for dep in dependencies if dep.name not in cached_packages
         ]
         downloaded_count = 0
 
         if remaining_deps:
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            with ThreadPoolExecutor(
+                max_workers=self.parent.config.max_workers
+            ) as executor:
                 future_to_dep = {
-                    executor.submit(self._download_package, dep, dest_dir): dep
+                    executor.submit(
+                        self._download_package, dep, self.cache.cache_dir
+                    ): dep
                     for dep in remaining_deps
                 }
 
@@ -920,17 +1058,12 @@ class LibraryDownloader:
                     dep = future_to_dep[future]
                     try:
                         wheel_file = future.result()
-                        normalized_dep_name = normalize_package_name(dep.name)
-                        results_list.append((
-                            normalized_dep_name,
-                            wheel_file is not None,
-                        ))
+                        results_list.append((dep.name, wheel_file is not None))
                         if wheel_file:
                             downloaded_count += 1
                     except Exception as e:
-                        normalized_dep_name = normalize_package_name(dep.name)
-                        logger.error(f"Error processing {normalized_dep_name}: {e}")
-                        results_list.append((normalized_dep_name, False))
+                        logger.error(f"Error processing {dep.name}: {e}")
+                        results_list.append((dep.name, False))
 
         # Convert to dictionary for final result
         results = dict(results_list)
@@ -948,36 +1081,58 @@ class LibraryDownloader:
         )
 
 
-class PyLibPack:
+@dataclass(frozen=True)
+class PyLibPacker:
     """Main library packer class."""
 
-    def __init__(
-        self,
-        cache_dir: Path | None = None,
-        python_version: str | None = None,
-        mirror: str = "pypi",
-        optimize: bool = True,
-        optimization_strategy: SelectiveExtractionStrategy | None = None,
-    ):
-        """Initialize library packer.
+    working_dir: Path
+    config: PyLibPackerConfig
 
-        Args:
-            cache_dir: Custom cache directory
-            python_version: Target Python version
-            mirror: PyPI mirror source (pypi, tsinghua, aliyun, ustc, douban, tencent)
-        """
-        self.cache = LibraryCache(cache_dir)
-        self.downloader = LibraryDownloader(self.cache, python_version, mirror)
+    @cached_property
+    def cache(self) -> LibraryCache:
+        return LibraryCache(cache_dir=self.config.cache_dir or DEFAULT_CACHE_DIR)
 
-        # Set up optimization strategy
-        self.optimize = optimize
-        self.optimization_strategy = (
-            optimization_strategy or SelectiveExtractionStrategy() if optimize else None
+    @cached_property
+    def downloader(self) -> LibraryDownloader:
+        return LibraryDownloader(
+            parent=self,
+            cache=self.cache,
+            _mirror=self.config.mirror,
         )
 
-    def pack_project(
-        self, project: Project, output_dir: Path, max_workers: int = 4
-    ) -> PackResult:
+    @cached_property
+    def optimization_strategy(self) -> SelectiveExtractionStrategy | None:
+        return SelectiveExtractionStrategy() if self.config.optimize else None
+
+    @cached_property
+    def solution(self) -> Solution:
+        return Solution.from_directory(root_dir=self.working_dir)
+
+    @cached_property
+    def projects(self) -> dict[str, Project]:
+        # Return projects as a dictionary mapping project names to Project objects
+        # This follows the Solution API correctly
+        return {project.name: project for project in self.solution.projects.values()}
+
+    @cached_property
+    def project_count(self) -> int:
+        """Get the count of projects to avoid repeated computation."""
+        return len(self.projects)
+
+    @cached_property
+    def working_dir_size(self) -> int:
+        """Calculate total size of the working directory in bytes."""
+        if not self.working_dir.exists():
+            return 0
+
+        # Use generator expression for memory efficiency
+        return sum(
+            file_path.stat().st_size
+            for file_path in self.working_dir.rglob("*")
+            if file_path.is_file()
+        )
+
+    def pack_project(self, project: Project) -> PackResult:
         """Pack dependencies for a single project.
 
         Args:
@@ -987,79 +1142,71 @@ class PyLibPack:
 
         Returns:
             PackResult containing packing statistics
-        """
-        logger.info(f"\n{'=' * 60}")
-        logger.info(f"Packing dependencies for project: {project.name}")
-        logger.info(f"{'=' * 60}")
-
-        if not project.dependencies:
-            logger.warning(f"No dependencies found for {project.name}")
-            return PackResult(
-                success=False,
-                message="No dependencies found",
-                project=project.name,
-                total=0,
-                successful=0,
-                failed=0,
-                packages_dir=str(output_dir),
-            )
 
-        logger.info(f"Found {len(project.dependencies)} dependencies")
-
-        # Download direct dependencies
-        download_result = self.downloader.download_packages(
-            project.dependencies,
-            self.cache.cache_dir,
-            max_workers=max_workers,
-        )
-
-        # Build package map (including both wheel and sdist files) and collect all required packages recursively
-        package_map: dict[str, Path] = {}
-
-        # Add wheel files to package map
-        for wheel_file in self.cache.cache_dir.glob("*.whl"):
-            pkg_name = self.cache._extract_package_name_from_wheel(wheel_file)
-            if pkg_name and pkg_name not in package_map:  # Prefer wheel files
-                normalized_pkg_name = normalize_package_name(pkg_name)
-                package_map[normalized_pkg_name] = wheel_file
-
-        # Add sdist files to package map (only if not already present)
-        for sdist_file in self.cache.cache_dir.glob("*.tar.gz"):
-            pkg_name = self.cache._extract_package_name_from_sdist(sdist_file)
-            if pkg_name and normalize_package_name(pkg_name) not in package_map:
-                normalized_pkg_name = normalize_package_name(pkg_name)
-                package_map[normalized_pkg_name] = sdist_file
+        Raises:
+            ValueError: If project has invalid configuration
+            RuntimeError: If packing fails due to system issues
+        """
+        logger.info(f"{120 * '='}")
+        logger.info(f"Packing dependencies for project: `{project.name}`")
 
-        for sdist_file in self.cache.cache_dir.glob("*.zip"):
-            pkg_name = self.cache._extract_package_name_from_sdist(sdist_file)
-            if pkg_name and normalize_package_name(pkg_name) not in package_map:
-                normalized_pkg_name = normalize_package_name(pkg_name)
-                package_map[normalized_pkg_name] = sdist_file
+        download_result = self.downloader.download_packages(project)
 
         # Recursively collect all dependencies (pass cache instance for dependency extraction)
-        all_packages = self._collect_all_dependencies(
-            package_map, list(download_result.results), self.cache
+        all_packages = self.cache.collect_dependencies_from_list(
+            list(download_result.results)
         )
 
         # Extract all required packages (keep order of dependency resolution)
         extracted_packages = []
         for pkg_name in all_packages:
-            if pkg_name in package_map:
+            logger.info(f"Processing {pkg_name}")
+            if pkg_name in self.cache.package_map:
                 # Skip if output directory already exists
-                output_pkg_dir = output_dir / pkg_name
+                output_pkg_dir = project.lib_dir / pkg_name
                 if output_pkg_dir.exists():
                     logger.warning(f"Output directory already exists: {output_pkg_dir}")
                     continue
 
-                package_file = package_map[pkg_name]
+                package_file = self.cache.package_map[pkg_name]
                 logger.info(f"Extracting {package_file.name}...")
-                self._extract_package(package_file, output_dir, pkg_name)
+                self._extract_package(package_file, project.lib_dir, pkg_name)
                 extracted_packages.append(pkg_name)
                 logger.info(f"Extracted {pkg_name}")
+            else:
+                logger.warning(f"Package not found in cache: {pkg_name}")
+                # Attempt to download the missing package
+                logger.info(f"Attempting to download missing package: {pkg_name}")
+
+                # Create a temporary dependency object for the missing package
+                missing_dep = Dependency(
+                    name=pkg_name, version=None, extras=set(), requires=set()
+                )
+
+                # Try to download the missing package
+                download_result = self.downloader._download_package(
+                    missing_dep, self.cache.cache_dir
+                )
+                if download_result:
+                    logger.info(f"Successfully downloaded missing package: {pkg_name}")
+                    # Now check again if it's in the cache and extract if available
+                    if pkg_name in self.cache.package_map:
+                        package_file = self.cache.package_map[pkg_name]
+                        logger.info(f"Extracting {package_file.name}...")
+                        self._extract_package(package_file, project.lib_dir, pkg_name)
+                        extracted_packages.append(pkg_name)
+                        logger.info(f"Extracted {pkg_name}")
+                    else:
+                        logger.error(
+                            f"Package {pkg_name} still not found in cache after download attempt"
+                        )
+                else:
+                    logger.error(f"Failed to download missing package: {pkg_name}")
 
         logger.info(
             f"Pack complete for {project.name}: {download_result.successful}/{download_result.total}"
         )
+        logger.info(f"{120 * '='}")
 
         return PackResult(
             success=download_result.successful > 0,
@@ -1067,76 +1214,10 @@ class PyLibPack:
             total=download_result.total,
             successful=download_result.successful,
             failed=download_result.total - download_result.successful,
-            packages_dir=str(output_dir),
+            packages_dir=str(project.lib_dir),
             extracted_packages=extracted_packages,
         )
 
-    @staticmethod
-    def _collect_all_dependencies(
-        package_map: dict[str, Path], root_packages: list[str], cache: LibraryCache
-    ) -> set[str]:
-        """Recursively collect all dependencies from package files (wheel or sdist).
-
-        Args:
-            package_map: Mapping of package names to package files (wheel or sdist)
-            root_packages: List of root package names to start from
-            cache: LibraryCache instance for extracting dependencies
-
-        Returns:
-            List of all required package names
-        """
-        all_packages: set[str] = set()
-        visited: set[str] = set()
-        visit_stack: dict[str, int] = {}  # Track visit depth for cycle detection
-
-        def visit(pkg_name: str, level: int = 0) -> None:
-            """Visit a package and collect its dependencies."""
-            # Normalize package name for consistency
-            normalized_pkg_name = normalize_package_name(pkg_name)
-
-            # Check for cycles
-            if normalized_pkg_name in visit_stack:
-                logger.warning(
-                    f"Potential circular dependency detected: {normalized_pkg_name} (current depth: {level}, "
-                    f"previous depth: {visit_stack[normalized_pkg_name]})"
-                )
-                return
-
-            # Check depth limit
-            if level > MAX_DEPTH:
-                logger.warning(
-                    f"Maximum dependency depth ({MAX_DEPTH}) reached for {normalized_pkg_name}, stopping recursion"
-                )
-                return
-
-            if normalized_pkg_name in visited:
-                return
-
-            # Mark as visited and track depth
-            visited.add(normalized_pkg_name)
-            visit_stack[normalized_pkg_name] = level
-            all_packages.add(normalized_pkg_name)
-
-            if normalized_pkg_name in package_map:
-                deps = cache._extract_dependencies_from_wheel(
-                    package_map[normalized_pkg_name]
-                )
-                logger.debug(f"{'  ' * level}{normalized_pkg_name} -> {deps}")
-                for dep in deps:
-                    visit(dep, level + 1)
-
-            # Remove from stack when done
-            visit_stack.pop(normalized_pkg_name, None)
-
-        for pkg_name in root_packages:
-            visit(pkg_name)
-
-        logger.info(
-            f"Collected {len(all_packages)} packages (including recursive dependencies)"
-        )
-        logger.info(f"Packages: {all_packages}")
-        return all_packages
-
     def _build_and_cache_wheel(self, sdist_file: Path, package_name: str) -> None:
         """Build wheel from sdist file and cache it for faster future access.
 
@@ -1199,181 +1280,175 @@ class PyLibPack:
         )
 
         # Handle sdist files (.tar.gz or .zip) - install using pip, and build wheel for cache
-        if package_file.suffix == ".gz" or package_file.suffix == ".zip":
-            logger.info(f"Installing sdist file for {package_name} using pip...")
-
-            # Use pip install --target to install sdist to temporary directory
-            with tempfile.TemporaryDirectory() as temp_install_dir:
-                result = subprocess.run(
-                    [
-                        self.downloader.pip_executable or "pip",
-                        "install",
-                        "--target",
-                        temp_install_dir,
-                        "--no-deps",  # Don't install dependencies (we handle them separately)
-                        "--no-cache-dir",
-                        str(package_file),
-                    ],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                )
+        if package_file.suffix in (".gz", ".zip"):
+            self._handle_sdist_extraction(package_file, dest_dir, package_name)
+            return
 
-                if result.returncode != 0:
-                    logger.error(
-                        f"Failed to install sdist {package_file.name}: {result.stderr}"
-                    )
-                    return
-
-                # Copy installed files to dest_dir, skipping *.dist-info directories
-                temp_install_path = Path(temp_install_dir)
-                for item in temp_install_path.iterdir():
-                    # Skip dist-info directories
-                    if item.name.endswith(".dist-info"):
-                        logger.debug(f"Skipping dist-info directory: {item.name}")
-                        continue
-                    dest_path = dest_dir / item.name
-                    if item.is_dir():
-                        if dest_path.exists():
-                            shutil.rmtree(dest_path)
-                        shutil.copytree(item, dest_path)
-                    else:
-                        shutil.copy2(item, dest_path)
+        # Handle wheel files with optional optimization
+        self._handle_wheel_extraction(package_file, dest_dir, package_name)
 
-                logger.info(
-                    f"Installed sdist file for {package_name} to site-packages structure"
+    def _handle_sdist_extraction(
+        self, package_file: Path, dest_dir: Path, package_name: str
+    ) -> None:
+        """Handle extraction of sdist files (.tar.gz or .zip)."""
+        logger.info(f"Installing sdist file for {package_name} using pip...")
+
+        # Use pip install --target to install sdist to temporary directory
+        with tempfile.TemporaryDirectory() as temp_install_dir:
+            result = subprocess.run(
+                [
+                    self.downloader.pip_executable or "pip",
+                    "install",
+                    "--target",
+                    temp_install_dir,
+                    "--no-deps",  # Don't install dependencies (we handle them separately)
+                    "--no-cache-dir",
+                    str(package_file),
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+            if result.returncode != 0:
+                logger.error(
+                    f"Failed to install sdist {package_file.name}: {result.stderr}"
                 )
+                return
 
-            # Build wheel from sdist and cache it for faster future access
-            logger.info(f"Building wheel from sdist for {package_name}...")
-            self._build_and_cache_wheel(package_file, package_name)
-            return
+            # Copy installed files to dest_dir, skipping *.dist-info directories
+            temp_install_path = Path(temp_install_dir)
+            # Pre-compute dist-info suffix
+            dist_info_suffix = ".dist-info"
 
-        # Handle wheel files with optional optimization
+            for item in temp_install_path.iterdir():
+                # Skip dist-info directories
+                if item.name.endswith(dist_info_suffix):
+                    logger.debug(f"Skipping dist-info directory: {item.name}")
+                    continue
+                dest_path = dest_dir / item.name
+                if item.is_dir():
+                    if dest_path.exists():
+                        shutil.rmtree(dest_path)
+                    shutil.copytree(item, dest_path)
+                else:
+                    shutil.copy2(item, dest_path)
+
+            logger.info(
+                f"Installed sdist file for {package_name} to site-packages structure"
+            )
+
+        # Build wheel from sdist and cache it for faster future access
+        logger.info(f"Building wheel from sdist for {package_name}...")
+        self._build_and_cache_wheel(package_file, package_name)
+
+    def _handle_wheel_extraction(
+        self, package_file: Path, dest_dir: Path, package_name: str
+    ) -> None:
+        """Handle extraction of wheel files with optional optimization."""
         with zipfile.ZipFile(package_file, "r") as zf:
-            if self.optimize and self.optimization_strategy:
-                # Apply optimization strategy - selectively extract files
-                extracted_count = 0
-                skipped_count = 0
-
-                for file_info in zf.filelist:
-                    file_path = Path(file_info.filename)
-                    # Skip dist-info directories
-                    if file_path.name.endswith(".dist-info") or any(
-                        parent.endswith(".dist-info") for parent in file_path.parts
-                    ):
-                        logger.debug(f"Skipping dist-info: {file_info.filename}")
-                        skipped_count += 1
-                        continue
-                    if self.optimization_strategy.should_extract_file(
-                        package_name, file_path
-                    ):
-                        zf.extract(file_info, dest_dir)
-                        extracted_count += 1
-                        logger.debug(f"Extracted {file_path} from {package_name}")
-                    else:
-                        skipped_count += 1
-                        logger.debug(
-                            f"Skipped {file_path} from {package_name} (filtered by optimization strategy)"
-                        )
+            if self.config.optimize and self.optimization_strategy:
+                self._extract_with_optimization(zf, dest_dir, package_name)
+            else:
+                self._extract_without_optimization(zf, dest_dir, package_name)
 
-                logger.info(
-                    f"Extraction complete for {package_name}: {extracted_count} extracted, {skipped_count} skipped"
-                )
+    def _extract_with_optimization(
+        self, zf: zipfile.ZipFile, dest_dir: Path, package_name: str
+    ) -> None:
+        """Extract wheel with optimization strategy applied."""
+        extracted_count = 0
+        skipped_count = 0
+
+        assert self.optimization_strategy is not None, "Optimization strategy is None"
+        should_extract = self.optimization_strategy.should_extract_file
+
+        for file_info in zf.filelist:
+            file_path = Path(file_info.filename)
+
+            # Skip dist-info directories
+            if LibraryCache._should_skip_dist_info(
+                file_path
+            ):  # Use LibraryCache method
+                logger.debug(f"Skipping dist-info: {file_info.filename}")
+                skipped_count += 1
+                continue
+
+            if should_extract(package_name, file_path):
+                zf.extract(file_info, dest_dir)
+                extracted_count += 1
+                logger.debug(f"Extracted {file_path} from {package_name}")
             else:
-                # Extract all files without optimization, but skip dist-info directories
-                for file_info in zf.filelist:
-                    file_path = Path(file_info.filename)
-                    # Skip dist-info directories
-                    if file_path.name.endswith(".dist-info") or any(
-                        parent.endswith(".dist-info") for parent in file_path.parts
-                    ):
-                        logger.debug(f"Skipping dist-info: {file_info.filename}")
-                        continue
-                    zf.extract(file_info, dest_dir)
-                logger.info(
-                    f"All files extracted for {package_name} (no optimization applied, dist-info skipped)"
+                skipped_count += 1
+                logger.debug(
+                    f"Skipped {file_path} from {package_name} (filtered by optimization strategy)"
                 )
 
-    def pack(
-        self,
-        working_dir: Path,
-        max_workers: int = 4,
-    ) -> BatchPackResult:
-        """Pack project dependencies from base directory.
+        logger.info(
+            f"Extraction complete for {package_name}: {extracted_count} extracted, {skipped_count} skipped"
+        )
 
-        Args:
-            base_dir: Base directory containing projects or a single project
-            output_dir: Output directory (default: base_dir/dist/site-packages)
-            max_workers: Maximum concurrent downloads
+    def _extract_without_optimization(
+        self, zf: zipfile.ZipFile, dest_dir: Path, package_name: str
+    ) -> None:
+        """Extract wheel without optimization, but skip dist-info directories."""
+        # Pre-compute the skip function
+        should_skip = LibraryCache._should_skip_dist_info  # Use LibraryCache method
+
+        for file_info in zf.filelist:
+            file_path = Path(file_info.filename)
+            # Skip dist-info directories
+            if not should_skip(file_path):
+                zf.extract(file_info, dest_dir)
+        logger.info(
+            f"All files extracted for {package_name} (no optimization applied, dist-info skipped)"
+        )
 
-        Returns:
-            BatchPackResult containing batch packing statistics
-        """
-        output_dir = working_dir / "dist" / "site-packages"
-        logger.info(f"Starting dependency pack for: {working_dir}")
-
-        projects = Solution.from_directory(root_dir=working_dir).projects
-        if not projects:
-            logger.error("Failed to load project information")
-            return BatchPackResult(
-                success=False,
-                total=0,
-                successful=0,
-                failed=0,
-                output_dir=str(output_dir),
-                total_time=0.0,
-            )
+    @staticmethod
+    def _should_skip_dist_info(file_path: Path) -> bool:
+        """Check if the file path should be skipped because it's a dist-info directory."""
+        if file_path.name.endswith(".dist-info"):
+            return True
+        # Check if any parent directory ends with .dist-info
+        return any(part.endswith(".dist-info") for part in file_path.parts)
 
-        logger.info(f"Found {len(projects)} project(s) to process")
+    def run(self) -> None:
+        """Pack project dependencies from base directory with concurrent processing."""
+        t0 = time.perf_counter()
+        project_count = self.project_count  # Use cached property
 
-        # Process each project
-        total_start = time.perf_counter()
-        success_count = 0
-        failed_projects: list[str] = []
-        use_current_dir = len(projects) == 1
+        logger.info(f"Starting to pack {project_count} projects")
 
-        for project in projects.values():
-            project_dir = working_dir if use_current_dir else working_dir / project.name
+        if project_count == 1:
+            # Single project: process directly
+            project = next(iter(self.projects.values()))
+            self.pack_project(project)
+        else:
+            # Multiple projects: process concurrently
+            logger.info(f"Packing {project_count} projects concurrently...")
+            with ThreadPoolExecutor(max_workers=self.config.max_workers) as executor:
+                futures = [
+                    executor.submit(self.pack_project, project)
+                    for project in self.projects.values()
+                ]
 
-            if not project_dir.is_dir():
-                logger.warning(f"Project directory not found: {project_dir}, skipping")
-                failed_projects.append(project.name)
-                continue
+                # Wait for all tasks to complete
+                for future in as_completed(futures):
+                    try:
+                        future.result()
+                    except Exception as e:
+                        logger.error(f"Project packing failed: {e}")
 
-            result = self.pack_project(project, output_dir, max_workers)
+        elapsed_time = time.perf_counter() - t0
+        logger.info(f"Packed {project_count} projects in {elapsed_time:.2f}s")
 
-            if result.success:
-                success_count += 1
-            else:
-                failed_projects.append(project.name)
-
-        total_time = time.perf_counter() - total_start
-
-        # Summary
-        logger.info(f"\n{'=' * 60}")
-        logger.info("Summary")
-        logger.info(f"{'=' * 60}")
-        logger.info(f"Total projects: {len(projects)}")
-        logger.info(f"Successfully packed: {success_count}")
-        logger.info(f"Failed: {len(failed_projects)}")
-        if failed_projects:
-            logger.info(f"Failed projects: {', '.join(failed_projects)}")
-        logger.info(f"Total time: {total_time:.2f}s")
-
-        return BatchPackResult(
-            success=len(failed_projects) == 0,
-            total=len(projects),
-            successful=success_count,
-            failed=len(failed_projects),
-            failed_projects=failed_projects,
-            output_dir=str(output_dir),
-            total_time=total_time,
-        )
+        # Log cache statistics after packing
+        logger.info(f"Cache statistics: {self.cache.cache_stats}")
 
-    def clear_cache(self) -> None:
-        """Clear the package cache."""
-        self.cache.clear_cache()
+    def show_stats(self):
+        logger.info(f"Project count: {self.project_count}")
+        logger.info(f"Total dependencies: {len(self.solution.dependencies)}")
+        logger.info(f"Working directory size: {self.working_dir_size} bytes")
+        logger.info(f"Cache statistics: {self.cache.cache_stats}")
 
 
 def parse_args() -> argparse.Namespace:
@@ -1397,12 +1472,16 @@ def parse_args() -> argparse.Namespace:
         "--python-version", type=str, default=None, help="Target Python version"
     )
     parser.add_argument(
-        "-j", "--jobs", type=int, default=4, help="Maximum concurrent downloads"
+        "-j",
+        "--jobs",
+        type=int,
+        default=DEFAULT_MAX_WORKERS,
+        help="Maximum concurrent downloads",
     )
     parser.add_argument(
         "--mirror",
         type=str,
-        default="aliyun",
+        default=DEFAULT_MIRROR,
         choices=("pypi", "tsinghua", "aliyun", "ustc", "douban", "tencent"),
         help="PyPI mirror source for faster downloads in China",
     )
@@ -1413,6 +1492,18 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Disable package optimization (extract all files)",
     )
+
+    # Add option to show package size
+    parser.add_argument(
+        "--show-size",
+        action="store_true",
+        help="Show packed package size",
+    )
+    parser.add_argument(
+        "--show-stats",
+        action="store_true",
+        help="Show detailed project statistics",
+    )
     parser.add_argument(
         "--list-optimizations",
         "-lo",
@@ -1426,6 +1517,10 @@ def main() -> None:
     """Main entry point for pylibpack tool."""
     args = parse_args()
 
+    # Setup logging
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
     if args.list_optimizations:
         strategy = SelectiveExtractionStrategy()
         logging.info("Available optimization rules:")
@@ -1433,25 +1528,28 @@ def main() -> None:
             logging.info(f"  - {lib_name}")
         return
 
-    # Setup logging
-    if args.debug:
-        logger.setLevel(logging.DEBUG)
-
-    # Initialize packer
-    cache_dir = Path(args.cache_dir) if args.cache_dir else None
-    optimize = not args.no_optimize
-    packer = PyLibPack(
-        cache_dir=cache_dir,
-        python_version=args.python_version,
+    # Create configuration from arguments
+    config = PyLibPackerConfig(
+        cache_dir=Path(args.cache_dir) if args.cache_dir else DEFAULT_CACHE_DIR,
         mirror=args.mirror,
-        optimize=optimize,
+        optimize=not args.no_optimize,
+        max_workers=args.jobs,
     )
 
-    packer.pack(
+    # Register auto-save on exit
+    atexit.register(config.save)
+
+    packer = PyLibPacker(
         working_dir=Path(args.directory),
-        max_workers=args.jobs,
+        config=config,
     )
 
+    # Execute pack operation
+    packer.run()
+
+    if args.show_stats:
+        packer.show_stats()
+
 
 if __name__ == "__main__":
     main()