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

sfi/pyembedinstall/pyembedinstall.py

@@ -9,7 +9,7 @@ import shutil
 import time
 import zipfile
 from contextlib import suppress
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
 from typing import Final
@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 
 # Default cache directory
 _DEFAULT_CACHE_DIR = Path.home() / ".pysfi" / ".cache" / "embed-python"
-
+_DEFAULT_PYTHON_VER = "3.8.10"
 
 # Architecture mapping
 ARCH_DICT: Final = {
@@ -44,31 +44,34 @@ USER_AGENT: Final = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.3
 class EmbedDownloader:
     """Class for downloading Python embeddable package."""
 
+    parent: EmbedInstaller
     version: str
-    arch: str
-    cache_dir: Path
-    offline: bool
-    skip_speed_test: bool
-    timeout: int = 5
 
     @cached_property
     def cache_file(self) -> Path:
         """Get the cache file path for the embeddable package."""
-        return self.cache_dir / f"python-{self.version}-embed-{self.arch}.zip"
+        return (
+            self.parent.cache_dir
+            / f"python-{self.version}-embed-{self.parent.arch}.zip"
+        )
 
     @cached_property
     def download_urls(self) -> list[str]:
         """Get the list of URLs to try for download."""
-        if self.skip_speed_test:
-            url = self.get_official_url_template(self.arch).format(version=self.version)
+        if self.parent.skip_speed_test:
+            url = self.get_official_url_template(self.parent.arch).format(
+                version=self.latest_path_version
+            )
             logger.info(f"Skipping speed test, using official URL: {url}")
             return [url]
-        return self.find_available_urls(self.version, self.arch, self.timeout)
+        return self.find_available_urls(
+            self.latest_path_version, self.parent.arch, self.parent.timeout
+        )
 
     def download(self) -> bool:
         """Download the Python embeddable package to the cache file."""
         return self.has_cached_file or self.download_python_package(
-            self.cache_file, self.download_urls, self.offline
+            self.cache_file, self.download_urls, self.parent.offline
         )
 
     @cached_property
@@ -91,9 +94,11 @@ class EmbedDownloader:
         return is_valid
 
     @cached_property
-    def latest_version(self) -> str | None:
+    def latest_path_version(self) -> str | None:
         """Get the latest version of Python available for download."""
-        version = self.get_latest_patch_version(self.version, self.arch, self.cache_dir)
+        version = self.get_latest_patch_version(
+            self.version, self.parent.arch, self.parent.cache_dir
+        )
         return version if "." in version else None
 
     def download_with_progress(self, url: str, dest_path: Path) -> None:
@@ -102,7 +107,7 @@ class EmbedDownloader:
 
         req = Request(url, headers={"User-Agent": USER_AGENT})
         try:
-            with urlopen(req, timeout=self.timeout) as response:
+            with urlopen(req, timeout=self.parent.timeout) as response:
                 total_size = int(response.headers.get("content-length", 0))
                 dest_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -204,12 +209,12 @@ class EmbedDownloader:
 
     def get_official_url_template(self, arch: str | None = None) -> str:
         """Get official URL template based on architecture."""
-        arch = arch or self.arch
+        arch = arch or self.parent.arch
         return f"https://www.python.org/ftp/python/{{version}}/python-{{version}}-embed-{arch}.zip"
 
     def get_mirror_url_templates(self, arch: str | None = None) -> list[str]:
         """Get mirror URL templates based on architecture."""
-        arch = arch or self.arch
+        arch = arch or self.parent.arch
         return [
             f"https://mirrors.huaweicloud.com/python/{{version}}/python-{{version}}-embed-{arch}.zip",
             f"https://mirrors.aliyun.com/python-release/{{version}}/python-{{version}}-embed-{arch}.zip",
@@ -221,7 +226,7 @@ class EmbedDownloader:
         self, url: str, timeout: int | None = None, use_get: bool = False
     ) -> float:
         """Test URL speed by making a HEAD or GET request."""
-        timeout = timeout or self.timeout
+        timeout = timeout or self.parent.timeout
         start_time = time.time()
 
         # First attempt HEAD request
@@ -268,7 +273,7 @@ class EmbedDownloader:
     ) -> list[str]:
         """Get list of URLs to test for speed."""
         version = version or self.version
-        arch = arch or self.arch
+        arch = arch or self.parent.arch
         return [
             template.format(version=version)
             for template in [
@@ -285,8 +290,8 @@ class EmbedDownloader:
     ) -> list[str]:
         """Find all available URLs for downloading Python embeddable package, sorted by speed."""
         version = version or self.version
-        arch = arch or self.arch
-        timeout = timeout or self.timeout
+        arch = arch or self.parent.arch
+        timeout = timeout or self.parent.timeout
         official_url = self.get_official_url_template(arch).format(version=version)
 
         logger.debug("Testing mirror speeds...")
@@ -434,37 +439,24 @@ class EmbedDownloader:
         return self.resolve_patch_version(major_minor, arch, cache_dir, timeout)
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=False)
 class EmbedInstaller:
     """Class for installing Python embeddable package."""
 
     root_dir: Path
-    version: str
-    cache_dir: Path
-    offline: bool
-    skip_speed_test: bool
-    keep_cache: bool
+    cache_dir: Path | None = field(default_factory=lambda: _DEFAULT_CACHE_DIR)
+    offline: bool = False
+    skip_speed_test: bool = False
     timeout: int = 5
 
     def __post_init__(self):
-        pass
+        if not self.cache_dir:
+            object.__setattr__(self, "cache_dir", _DEFAULT_CACHE_DIR)
 
     @cached_property
     def solution(self) -> Solution:
         """Get the solution from the target directory."""
-        return Solution.from_directory(self.root_dir)
-
-    @cached_property
-    def downloader(self) -> EmbedDownloader:
-        """Get the embed downloader for the given version and architecture."""
-        return EmbedDownloader(
-            version=self.version,
-            arch=self.arch,
-            cache_dir=self.cache_dir,
-            offline=self.offline,
-            skip_speed_test=self.skip_speed_test,
-            timeout=self.timeout,
-        )
+        return Solution.from_directory(self.root_dir, update=True)
 
     @cached_property
     def arch(self) -> str:
@@ -484,15 +476,10 @@ class EmbedInstaller:
         """Get the path to python.exe in the target directory."""
         return self.runtime_dir / "python.exe"
 
-    @cached_property
-    def cache_file(self) -> Path:
-        """Get the path to the cache file."""
-        return self.downloader.cache_file
-
-    def extract_package(self) -> bool:
+    def extract_package(self, downloader: EmbedDownloader) -> bool:
         """Extract package to target directory."""
-        if not zipfile.is_zipfile(self.cache_file):
-            logger.error(f"Invalid zip file: {self.cache_file}")
+        if not zipfile.is_zipfile(downloader.cache_file):
+            logger.error(f"Invalid zip file: {downloader.cache_file}")
             return False
 
         try:
@@ -500,50 +487,71 @@ class EmbedInstaller:
             self.runtime_dir.mkdir(parents=True, exist_ok=True)
 
             # First get file count for progress
-            with zipfile.ZipFile(self.cache_file, "r") as zip_ref:
+            with zipfile.ZipFile(downloader.cache_file, "r") as zip_ref:
                 file_count = len(zip_ref.namelist())
 
             # Extract the archive
-            shutil.unpack_archive(str(self.cache_file), str(self.runtime_dir), "zip")
+            shutil.unpack_archive(
+                str(downloader.cache_file), str(self.runtime_dir), "zip"
+            )
             logger.info(f"Extracted {file_count} files")
             return True
         except (zipfile.BadZipFile, OSError) as e:
             logger.error(f"Failed to extract: {e}")
             return False
 
-    def cleanup_cache(self) -> None:
-        """Clean up cache file if not keeping it."""
-        if not self.keep_cache and not self.offline:
-            try:
-                if self.cache_file.exists():
-                    logger.debug(f"Cleaning up cache: {self.cache_file}")
-                    self.cache_file.unlink()
-            except OSError as e:
-                logger.warning(f"Failed to clean up cache file: {e}")
-
-    def install_package(self) -> bool:
+    def run(self) -> bool:
         """Install Python embeddable package to target directory using embedded methods."""
         # Download the package (latest_version is resolved automatically during download)
-        if not self.downloader.download():
-            logger.error("Failed to download Python embeddable package")
-            return False
+        results = []
+        total_processed = 0
+        extracted = False  # Track if we've already extracted for any project
+
+        for project in self.solution.projects.values():
+            if not project.min_python_version:
+                logger.warning(
+                    f"Project {project.name} does not have a minimum Python version"
+                )
+                continue
+
+            logger.info(f"Processing project: `{project.name}`")
+            total_processed += 1
+            downloader = EmbedDownloader(
+                parent=self,
+                version=project.min_python_version or _DEFAULT_PYTHON_VER,
+            )
 
-        # Extract the package to runtime directory
-        if not self.extract_package():
-            logger.error("Failed to extract Python embeddable package")
-            return False
+            if not downloader.download():
+                logger.error("Failed to download Python embeddable package")
+                continue
+
+            # Extract the package to runtime directory only once
+            # All projects share the same embed Python runtime
+            if not extracted:
+                if self.python_exe_path.exists():
+                    logger.info(
+                        f"Python runtime already exists at {self.runtime_dir}, skipping extraction"
+                    )
+                    extracted = True
+                elif self.extract_package(downloader):
+                    extracted = True
+                else:
+                    logger.error("Failed to extract Python embeddable package")
+                    continue
 
-        # Clean up cache if not keeping it
-        self.cleanup_cache()
+            # Verify installation by checking for python.exe
+            results.append(self.python_exe_path.exists())
 
-        # Verify installation by checking for python.exe
-        success = self.python_exe_path.exists()
-        if success:
-            logger.info(f"Installation completed, python.exe: {self.python_exe_path}")
-        else:
-            logger.error("Installation failed, python.exe not found")
+        if total_processed == 0:
+            logger.error("No projects with minimum Python version found to process")
+            return False
 
-        return success
+        if all(results) and len(results) > 0:
+            logger.info("Python embeddable package installed successfully")
+            return True
+        else:
+            logger.error("Failed to install Python embeddable package")
+            return False
 
 
 def parse_args() -> argparse.Namespace:
@@ -570,7 +578,7 @@ def parse_args() -> argparse.Namespace:
         "--version",
         "-v",
         type=str,
-        default="3.8.10",
+        default=_DEFAULT_PYTHON_VER,
         help="Python version to install (default: 3.8.10)",
     )
     parser.add_argument(
@@ -580,13 +588,6 @@ def parse_args() -> argparse.Namespace:
         default=str(_DEFAULT_CACHE_DIR),
         help="Cache directory for downloaded files",
     )
-    parser.add_argument(
-        "--keep-cache",
-        "-k",
-        action="store_true",
-        default=True,
-        help="Keep downloaded cache files",
-    )
     parser.add_argument(
         "--skip-speed-test",
         "-s",
@@ -617,13 +618,11 @@ def main() -> None:
 
     if not EmbedInstaller(
         root_dir=Path(args.directory),
-        version=args.version,
         cache_dir=cache_dir,
         offline=args.offline,
         skip_speed_test=args.skip_speed_test,
-        keep_cache=args.keep_cache,
         timeout=args.timeout,
-    ).install_package():
+    ).run():
         exit(1)
 
     logger.info(f"Installation completed in {time.perf_counter() - t0:.4f} seconds")