Add downloadable SKY130 PDK bundle flow

Author: ROMERUU-dev

app/core/dependency_manifest.py

@@ -24,6 +24,15 @@ class ChannelPolicy:
     pdk_source_build_open_pdks_repo: str
     pdk_source_build_open_pdks_ref: str
     pdk_source_build_configure_args: tuple[str, ...]
+    pdk_bundle_enabled: bool
+    pdk_bundle_name: str
+    pdk_bundle_version: str
+    pdk_bundle_install_root: str
+    pdk_bundle_cache_root: str
+    pdk_bundle_minimum_free_gb: int
+    pdk_bundle_asset_url: str
+    pdk_bundle_asset_filename: str
+    pdk_bundle_asset_sha256: str
     pdk_preferred_sources: tuple[str, ...]
     pdk_search_roots: tuple[str, ...]
 
@@ -64,6 +73,15 @@ def channel(self, name: str | None = None) -> ChannelPolicy:
             pdk_source_build_open_pdks_repo=str(pdk.get("source_build_open_pdks_repo", "")),
             pdk_source_build_open_pdks_ref=str(pdk.get("source_build_open_pdks_ref", "")),
             pdk_source_build_configure_args=tuple(str(item) for item in pdk.get("source_build_configure_args", [])),
+            pdk_bundle_enabled=bool(pdk.get("bundle", {}).get("enabled", False)),
+            pdk_bundle_name=str(pdk.get("bundle", {}).get("name", "tt-pdk-sky130a")),
+            pdk_bundle_version=str(pdk.get("bundle", {}).get("version", "")),
+            pdk_bundle_install_root=str(pdk.get("bundle", {}).get("install_root", "~/tt-pdk")),
+            pdk_bundle_cache_root=str(pdk.get("bundle", {}).get("cache_root", "~/.cache/sky130-flow-gui/pdk")),
+            pdk_bundle_minimum_free_gb=int(pdk.get("bundle", {}).get("minimum_free_gb", 10)),
+            pdk_bundle_asset_url=str(pdk.get("bundle", {}).get("asset_url", "")),
+            pdk_bundle_asset_filename=str(pdk.get("bundle", {}).get("asset_filename", "")),
+            pdk_bundle_asset_sha256=str(pdk.get("bundle", {}).get("asset_sha256", "")),
             pdk_preferred_sources=tuple(str(item) for item in pdk.get("preferred_sources", [])),
             pdk_search_roots=tuple(str(item) for item in pdk.get("search_roots", [])),
         )

app/core/setup_manager.py

@@ -6,6 +6,7 @@
 import os
 from pathlib import Path
 import shutil
+import sys
 
 from app.core.dependency_manifest import DependencyManifest
 from app.core.env_validator import EnvValidator, REQUIRED_PDK_SUBDIRS
@@ -68,6 +69,28 @@ class PdkSourceBuildPreflight:
     message: str
 
 
+@dataclass(frozen=True)
+class PdkBundlePreflight:
+    """Precheck summary for downloading and installing a TT-style PDK bundle."""
+
+    enabled: bool
+    bundle_name: str
+    bundle_version: str
+    install_root: str
+    target_sky130a: str
+    cache_root: str
+    asset_url: str
+    asset_filename: str
+    asset_sha256: str
+    minimum_free_bytes: int
+    free_bytes: int
+    enough_space: bool
+    target_available: bool
+    target_status: str
+    ready: bool
+    message: str
+
+
 class SetupManager:
     """Detect common installations and provide installer entrypoints."""
 
@@ -82,12 +105,18 @@ def installer_script(self) -> Path:
     def pdk_source_build_script(self) -> Path:
         return self.repo_root / "scripts" / "build_sky130_pdk_from_sources.sh"
 
+    def pdk_bundle_install_script(self) -> Path:
+        return self.repo_root / "scripts" / "install_tt_pdk_bundle.py"
+
     def installer_command(self) -> list[str]:
         return ["pkexec", "/bin/bash", str(self.installer_script()), self.manifest.default_channel()]
 
     def pdk_source_build_command(self) -> list[str]:
         return ["/bin/bash", str(self.pdk_source_build_script()), self.manifest.default_channel()]
 
+    def pdk_bundle_install_command(self) -> list[str]:
+        return [sys.executable, str(self.pdk_bundle_install_script()), self.manifest.default_channel()]
+
     def bootstrap_packages(self, channel: str | None = None) -> tuple[str, ...]:
         return self.manifest.channel(channel).apt_packages
 
@@ -312,6 +341,59 @@ def pdk_source_build_preflight(self, settings: AppSettings) -> PdkSourceBuildPre
             message="; ".join(message_parts),
         )
 
+    def pdk_bundle_preflight(self, settings: AppSettings) -> PdkBundlePreflight:
+        policy = self.manifest.channel()
+        install_root = Path(policy.pdk_bundle_install_root).expanduser()
+        target_sky130a = install_root / "sky130A"
+        cache_root = Path(policy.pdk_bundle_cache_root).expanduser()
+        usage_root = install_root if install_root.exists() else install_root.parent if install_root.parent.exists() else Path.home()
+        free_bytes = shutil.disk_usage(usage_root).free
+        minimum_free_bytes = policy.pdk_bundle_minimum_free_gb * 1024 * 1024 * 1024
+        enough_space = free_bytes >= minimum_free_bytes
+        target_status = self._classify_sky130a_path(target_sky130a)
+        target_available = not os.path.lexists(target_sky130a)
+        has_asset = bool(policy.pdk_bundle_enabled and policy.pdk_bundle_asset_url and policy.pdk_bundle_asset_filename)
+        ready = has_asset and enough_space and target_available
+
+        message_parts = [
+            f"bundle={policy.pdk_bundle_name}",
+            f"install_root={install_root}",
+            f"target={target_sky130a}",
+            f"cache_root={cache_root}",
+            f"free_gb={free_bytes / (1024 ** 3):.1f}",
+        ]
+        if policy.pdk_bundle_version:
+            message_parts.append(f"version={policy.pdk_bundle_version}")
+        if not policy.pdk_bundle_enabled:
+            message_parts.append("bundle_disabled")
+        if not policy.pdk_bundle_asset_url:
+            message_parts.append("missing_asset_url")
+        if not policy.pdk_bundle_asset_filename:
+            message_parts.append("missing_asset_filename")
+        if not enough_space:
+            message_parts.append(f"requires_at_least={policy.pdk_bundle_minimum_free_gb}GB")
+        if not target_available:
+            message_parts.append(f"target_status={target_status}")
+
+        return PdkBundlePreflight(
+            enabled=policy.pdk_bundle_enabled,
+            bundle_name=policy.pdk_bundle_name,
+            bundle_version=policy.pdk_bundle_version,
+            install_root=str(install_root),
+            target_sky130a=str(target_sky130a),
+            cache_root=str(cache_root),
+            asset_url=policy.pdk_bundle_asset_url,
+            asset_filename=policy.pdk_bundle_asset_filename,
+            asset_sha256=policy.pdk_bundle_asset_sha256,
+            minimum_free_bytes=minimum_free_bytes,
+            free_bytes=free_bytes,
+            enough_space=enough_space,
+            target_available=target_available,
+            target_status=target_status,
+            ready=ready,
+            message="; ".join(message_parts),
+        )
+
     def apply_detected_defaults(self, settings: AppSettings) -> bool:
         changed = False
 

app/data/dependency_manifest.json

@@ -55,6 +55,17 @@
         "source_build_configure_args": [
           "--enable-sky130-pdk"
         ],
+        "bundle": {
+          "enabled": true,
+          "name": "tt-pdk-sky130a",
+          "version": "0.2.0-beta.2",
+          "install_root": "~/pdk",
+          "cache_root": "~/.cache/sky130-flow-gui/pdk",
+          "minimum_free_gb": 10,
+          "asset_url": "https://github.com/ROMERUU-dev/sky130-flow-gui/releases/download/v0.2.0-beta.2/tt-pdk-sky130a_0.2.0-beta.2.tar.gz",
+          "asset_filename": "tt-pdk-sky130a_0.2.0-beta.2.tar.gz",
+          "asset_sha256": "25acfcdaace6e6b8ca0ca828407ecf1a896a1c0e04560465d2259cda8b9b4c24"
+        },
         "preferred_sources": [
           "settings",
           "environment",
@@ -125,6 +136,17 @@
         "source_build_configure_args": [
           "--enable-sky130-pdk"
         ],
+        "bundle": {
+          "enabled": true,
+          "name": "tt-pdk-sky130a",
+          "version": "0.2.0-beta.2",
+          "install_root": "~/pdk",
+          "cache_root": "~/.cache/sky130-flow-gui/pdk",
+          "minimum_free_gb": 10,
+          "asset_url": "https://github.com/ROMERUU-dev/sky130-flow-gui/releases/download/v0.2.0-beta.2/tt-pdk-sky130a_0.2.0-beta.2.tar.gz",
+          "asset_filename": "tt-pdk-sky130a_0.2.0-beta.2.tar.gz",
+          "asset_sha256": "25acfcdaace6e6b8ca0ca828407ecf1a896a1c0e04560465d2259cda8b9b4c24"
+        },
         "preferred_sources": [
           "settings",
           "environment",

app/ui/setup_tab.py

@@ -92,6 +92,7 @@ def __init__(self, settings: AppSettings) -> None:
         self._pdk_candidates_available = False
         self._pdk_preflight = None
         self._pdk_source_preflight = None
+        self._pdk_bundle_preflight = None
         self._runner_action = ""
 
         self.validate_btn = QPushButton(pick(self.lang, "Validar entorno", "Validate environment"))
@@ -101,6 +102,7 @@ def __init__(self, settings: AppSettings) -> None:
         self.detect_pdk_btn = QPushButton(pick(self.lang, "Buscar PDK reutilizable", "Find reusable PDK"))
         self.use_pdk_btn = QPushButton(pick(self.lang, "Usar PDK seleccionado", "Use selected PDK"))
         self.install_managed_pdk_btn = QPushButton(pick(self.lang, "Instalar PDK gestionado", "Install managed PDK"))
+        self.install_bundle_pdk_btn = QPushButton(pick(self.lang, "Descargar bundle PDK", "Download PDK bundle"))
         self.check_source_build_btn = QPushButton(pick(self.lang, "Precheck build desde fuentes", "Source-build precheck"))
         self.build_from_sources_btn = QPushButton(pick(self.lang, "Build PDK desde fuentes", "Build PDK from sources"))
         self.pdk_candidate_combo = QComboBox()
@@ -109,6 +111,8 @@ def __init__(self, settings: AppSettings) -> None:
         self.pdk_candidate_summary.setWordWrap(True)
         self.pdk_preflight_summary = QLabel()
         self.pdk_preflight_summary.setWordWrap(True)
+        self.pdk_bundle_summary = QLabel()
+        self.pdk_bundle_summary.setWordWrap(True)
         self.pdk_source_preflight_summary = QLabel()
         self.pdk_source_preflight_summary.setWordWrap(True)
         self.prev_btn = QPushButton(pick(self.lang, "Atrás", "Back"))
@@ -357,10 +361,13 @@ def _build_pdk_page(self) -> QWidget:
         actions.addWidget(self.detect_pdk_btn)
         actions.addWidget(self.use_pdk_btn)
         actions.addWidget(self.install_managed_pdk_btn)
+        actions.addWidget(self.install_bundle_pdk_btn)
         actions.addStretch(1)
         layout.addLayout(actions)
         layout.addWidget(QLabel(pick(self.lang, "Preflight de instalación gestionada", "Managed install preflight")))
         layout.addWidget(self.pdk_preflight_summary)
+        layout.addWidget(QLabel(pick(self.lang, "Bundle PDK", "PDK bundle")))
+        layout.addWidget(self.pdk_bundle_summary)
         source_actions = QHBoxLayout()
         source_actions.addWidget(self.check_source_build_btn)
         source_actions.addWidget(self.build_from_sources_btn)
@@ -451,6 +458,7 @@ def _wire(self) -> None:
         self.detect_pdk_btn.clicked.connect(self.refresh_pdk_candidates)
         self.use_pdk_btn.clicked.connect(self.apply_selected_pdk_candidate)
         self.install_managed_pdk_btn.clicked.connect(self.install_managed_pdk)
+        self.install_bundle_pdk_btn.clicked.connect(self.install_bundle_pdk)
         self.check_source_build_btn.clicked.connect(self.refresh_pdk_source_preflight)
         self.build_from_sources_btn.clicked.connect(self.build_pdk_from_sources)
         self.pdk_candidate_combo.currentIndexChanged.connect(self._update_pdk_candidate_summary)
@@ -581,6 +589,7 @@ def refresh_pdk_candidates(self) -> None:
         if self.pdk_candidate_combo.count() and self.pdk_candidate_combo.currentIndex() < 0:
             self.pdk_candidate_combo.setCurrentIndex(0)
         self._refresh_pdk_preflight()
+        self.refresh_pdk_bundle_preflight()
         self.refresh_pdk_source_preflight()
         self._update_pdk_candidate_summary()
         self._sync_action_gates()
@@ -661,6 +670,64 @@ def refresh_pdk_source_preflight(self) -> None:
         )
         self._sync_action_gates()
 
+    def refresh_pdk_bundle_preflight(self) -> None:
+        self._pdk_bundle_preflight = self.setup_mgr.pdk_bundle_preflight(self.settings)
+        summary = self._pdk_bundle_preflight
+        self.pdk_bundle_summary.setText(
+            pick(
+                self.lang,
+                f"Bundle: {summary.bundle_name}\n"
+                f"Versión: {summary.bundle_version or 'pendiente'}\n"
+                f"Instalación TT: {summary.target_sky130a}\n"
+                f"Cache: {summary.cache_root}\n"
+                f"Espacio libre: {summary.free_bytes / (1024 ** 3):.1f} GB\n"
+                f"Asset configurado: {'sí' if bool(summary.asset_url and summary.asset_filename) else 'no'}\n"
+                f"Listo para instalar: {'sí' if summary.ready else 'no'}",
+                f"Bundle: {summary.bundle_name}\n"
+                f"Version: {summary.bundle_version or 'pending'}\n"
+                f"TT install: {summary.target_sky130a}\n"
+                f"Cache: {summary.cache_root}\n"
+                f"Free space: {summary.free_bytes / (1024 ** 3):.1f} GB\n"
+                f"Asset configured: {'yes' if bool(summary.asset_url and summary.asset_filename) else 'no'}\n"
+                f"Ready to install: {'yes' if summary.ready else 'no'}",
+            )
+        )
+        self._sync_action_gates()
+
+    def install_bundle_pdk(self) -> None:
+        self.refresh_pdk_bundle_preflight()
+        summary = self._pdk_bundle_preflight
+        if summary is None or not summary.ready:
+            self.log.append(
+                pick(
+                    self.lang,
+                    "El bundle PDK todavía no está listo para descargarse e instalarse. Revisa el panel del bundle.\n",
+                    "The PDK bundle is not ready to download and install yet. Review the bundle panel.\n",
+                )
+            )
+            return
+        script_path = self.setup_mgr.pdk_bundle_install_script()
+        if not script_path.exists():
+            self.log.append(
+                pick(
+                    self.lang,
+                    f"Script del bundle no encontrado: {script_path}\n",
+                    f"Bundle script not found: {script_path}\n",
+                )
+            )
+            return
+        self._begin_activity(pick(self.lang, "Descargando bundle PDK...", "Downloading PDK bundle..."))
+        self.log.append(
+            pick(
+                self.lang,
+                "Descargando e instalando el bundle PDK en la ruta canónica del usuario. Esto puede tardar bastante.\n",
+                "Downloading and installing the PDK bundle into the user's canonical path. This can take a while.\n",
+            )
+        )
+        self.send_status.emit(pick(self.lang, "Instalando bundle PDK", "Installing PDK bundle"))
+        self._runner_action = "install_pdk_bundle"
+        self.runner.run(CommandSpec(command=self.setup_mgr.pdk_bundle_install_command()))
+
     def build_pdk_from_sources(self) -> None:
         self.refresh_pdk_source_preflight()
         summary = self._pdk_source_preflight
@@ -756,6 +823,22 @@ def _on_finished(self, code: int, status: str) -> None:
             self._finish_activity(True, pick(self.lang, "Build de PDK listo", "PDK build ready"))
             return
 
+        if code == 0 and action == "install_pdk_bundle":
+            self.log.append(
+                pick(
+                    self.lang,
+                    "\nBundle PDK instalado. Refrescando detección y validación.\n",
+                    "\nPDK bundle installed. Refreshing detection and validation.\n",
+                )
+            )
+            self.send_status.emit(pick(self.lang, "Bundle PDK listo", "PDK bundle ready"))
+            self.refresh_detection()
+            self.refresh_validation()
+            self._apply_detected_defaults(automatic=True)
+            self._set_step(3)
+            self._finish_activity(True, pick(self.lang, "Bundle PDK listo", "PDK bundle ready"))
+            return
+
         if action == "build_pdk_sources":
             self.log.append(
                 pick(
@@ -769,6 +852,19 @@ def _on_finished(self, code: int, status: str) -> None:
             self._finish_activity(False, pick(self.lang, "Build de PDK falló", "PDK build failed"))
             return
 
+        if action == "install_pdk_bundle":
+            self.log.append(
+                pick(
+                    self.lang,
+                    f"\nLa instalación del bundle PDK falló (exit={code}, status={status}). Revisa el log y la configuración del asset.\n",
+                    f"\nPDK bundle installation failed (exit={code}, status={status}). Review the log and the asset configuration.\n",
+                )
+            )
+            self.send_status.emit(pick(self.lang, "Bundle PDK falló", "PDK bundle failed"))
+            self.refresh_pdk_bundle_preflight()
+            self._finish_activity(False, pick(self.lang, "Bundle PDK falló", "PDK bundle failed"))
+            return
+
         if action == "install_tools":
             self.log.append(
                 pick(
@@ -938,6 +1034,7 @@ def _set_action_buttons_enabled(self, enabled: bool) -> None:
             self.detect_pdk_btn.setEnabled(False)
             self.use_pdk_btn.setEnabled(False)
             self.install_managed_pdk_btn.setEnabled(False)
+            self.install_bundle_pdk_btn.setEnabled(False)
             self.check_source_build_btn.setEnabled(False)
             self.build_from_sources_btn.setEnabled(False)
             self.prev_btn.setEnabled(False)
@@ -964,6 +1061,11 @@ def _sync_action_gates(self) -> None:
             and self._pdk_preflight.existing_status == "missing"
             and bool(self._pdk_preflight.selected_candidate)
         )
+        self.install_bundle_pdk_btn.setEnabled(
+            self._verification_completed
+            and self._pdk_bundle_preflight is not None
+            and self._pdk_bundle_preflight.ready
+        )
         self.check_source_build_btn.setEnabled(self._verification_completed)
         self.build_from_sources_btn.setEnabled(
             self._verification_completed
@@ -1022,6 +1124,21 @@ def _sync_action_gates(self) -> None:
                 "Install a managed PDK in the configured canonical path.",
             )
         )
+        self.install_bundle_pdk_btn.setToolTip(
+            pick(
+                self.lang,
+                "Primero verifica el sistema y configura un asset del bundle PDK en el manifiesto." if not self._verification_completed else
+                "El bundle PDK sigue bloqueado por configuración, espacio o porque ya existe el destino." if (
+                    self._pdk_bundle_preflight is None or not self._pdk_bundle_preflight.ready
+                ) else
+                "Descarga e instala un bundle `sky130A` ya preparado en `~/pdk`.",
+                "Verify the system first and configure a PDK bundle asset in the manifest." if not self._verification_completed else
+                "The PDK bundle is still blocked by configuration, space, or because the target already exists." if (
+                    self._pdk_bundle_preflight is None or not self._pdk_bundle_preflight.ready
+                ) else
+                "Download and install a prebuilt `sky130A` bundle into `~/pdk`.",
+            )
+        )
         self.build_from_sources_btn.setToolTip(
             pick(
                 self.lang,