driverclient 0.2.18__tar.gz → 0.2.19__tar.gz

{driverclient-0.2.18 → driverclient-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.18
+Version: 0.2.19
 Summary: Driver Server client with an embeddable connector for config injection at runtime.
 Project-URL: Homepage, https://example.com/driverclient
 Author-email: Raja Sanaullah <sanaullah@99technologies.com>

{driverclient-0.2.18 → driverclient-0.2.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "driverclient"
-version = "0.2.18"
+version = "0.2.19"
 description = "Driver Server client with an embeddable connector for config injection at runtime."
 readme = "README.md"
 requires-python = ">=3.10"

{driverclient-0.2.18 → driverclient-0.2.19}/src/driverclient/__init__.py

@@ -25,7 +25,7 @@ from driverclient.main import run as _run
 
 __all__ = ["DriverClient", "ClientEvent"]
 
-__version__ = "0.2.18"
+__version__ = "0.2.19"
 
 
 class DriverClient:

{driverclient-0.2.18 → driverclient-0.2.19}/src/driverclient/ops/install.py

@@ -68,6 +68,7 @@ class DriverResult:
     error:           str  = ""
     duration_ms:     int  = 0
     reboot_required: bool = False   # installed OK but needs a reboot (pnputil 3010)
+    skipped:         bool = False   # already present in the driver store — not re-fetched/installed
 
 
 @dataclass
@@ -154,9 +155,17 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # at the same-or-newer version — so a still-current big driver (graphics) is not
     # re-downloaded, while missing/extension drivers still install. Toggle off with
     # skip_installed_drivers=false to force-reinstall everything.
+    # Live driver-store index: INF name -> highest installed version. Built once,
+    # then UPDATED as each driver installs this pass (see _record_installed) so a
+    # later package of the same driver family (same INF) at an equal-or-older
+    # version is skipped — the driver store already has it. This is skip-if-present
+    # (idempotency), NOT deduplication: no repo package is removed; a newer repo
+    # version still installs over an older store version (store_ver >= repo_ver skips).
+    skip_installed = cfg.get("skip_installed_drivers", True)
+    idx: dict = _installed_inf_index() if skip_installed else {}
+
     drivers = result.drivers
-    if cfg.get("skip_installed_drivers", True):
-        idx = _installed_inf_index()
+    if skip_installed:
         kept = [d for d in drivers if not _already_in_store(d, idx)]
         skipped = len(drivers) - len(kept)
         if skipped:
@@ -179,21 +188,24 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     events.start("install",
                  f"[install] {len(drivers)} driver(s) — starting parallel downloads…",
                  total=len(drivers))
-    all_results = _stream_install(drivers, work_dir, cfg)
+    all_results = _stream_install(drivers, work_dir, cfg, idx, skip_installed)
 
     shutil.rmtree(work_dir, ignore_errors=True)
 
-    installed_ok   = [r for r in all_results if r.success]
+    installed_ok   = [r for r in all_results if r.success and not r.skipped]
+    skipped_now    = [r for r in all_results if r.skipped]
     install_failed = [r for r in all_results if not r.success]
 
-    _confirm(result.trace_id, installed_ok, install_failed, cfg)
+    # Skipped drivers ARE satisfied on the machine — report them upstream as success.
+    _confirm(result.trace_id, installed_ok + skipped_now, install_failed, cfg)
 
     reboot_required = any(r.reboot_required for r in installed_ok)
     reboot_tag = "  — reboot required" if reboot_required else ""
+    skip_tag   = f"  ({len(skipped_now)} already in store)" if skipped_now else ""
     events.done("install",
-                f"[install] Done — {len(installed_ok)} ok  {len(install_failed)} failed{reboot_tag}",
+                f"[install] Done — {len(installed_ok)} ok  {len(install_failed)} failed{skip_tag}{reboot_tag}",
                 total=len(all_results), ok=len(installed_ok), failed=len(install_failed),
-                reboot_required=reboot_required)
+                skipped=len(skipped_now), reboot_required=reboot_required)
     for r in install_failed:
         events.error("install", f"  ✗ {r.binding_id}: {r.error}",
                      binding_id=r.binding_id, error=r.error)
@@ -207,10 +219,16 @@ def resolve_and_install(force: bool = False) -> InstallResult:
 
 # ── Streaming pipeline ──────────────────────────────────────────────────────────
 
-def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverResult]:
+def _stream_install(drivers: list[dict], base: Path, cfg: dict,
+                    idx: dict, skip_installed: bool) -> list[DriverResult]:
     """
     Submit ALL downloads (all levels) simultaneously, then install level-by-level.
     Each driver installs the moment its own download Future completes.
+
+    `idx` is the live driver-store index (INF -> installed version); it is read to
+    skip a driver the store already has and updated after each successful install
+    so same-family duplicates later in the pass are skipped too. Installs run one
+    at a time here (main thread), so mutating `idx` needs no lock.
     """
     repo_url = cfg["local_repo_url"]
     parallel = cfg.get("parallel_downloads", 6)
@@ -225,7 +243,7 @@ def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverRe
                         f"[install] {_level_label(level)} ({len(level_futs[level])} driver(s))…",
                         category=_level_label(level), count=len(level_futs[level]))
         for fut in as_completed(level_futs[level]):
-            all_results.append(_process_completed(fut, future_info, cfg))
+            all_results.append(_process_completed(fut, future_info, cfg, idx, skip_installed))
 
     executor.shutdown(wait=False)
     return all_results
@@ -266,12 +284,23 @@ def _process_completed(
     fut: Future,
     future_info: dict[Future, tuple[int, dict]],
     cfg: dict,
+    idx: dict,
+    skip_installed: bool,
 ) -> DriverResult:
     """Handle one completed download Future: install if ok, return DriverResult."""
     _, driver = future_info[fut]
     bid = driver.get("binding_id", "")
     cat = driver.get("category", "other")
 
+    # A driver installed earlier THIS pass may have added the same INF (another
+    # package of the same driver family), so a package that was missing at
+    # pass-start can now already be in the store at an equal-or-newer version.
+    # Re-check against the live index and skip the redundant re-install.
+    if skip_installed and _already_in_store(driver, idx):
+        events.ok("install", f"  ⭑ [{cat}] {bid}  already in driver store — skipped",
+                  binding_id=bid, category=cat, skipped=True)
+        return DriverResult(binding_id=bid, success=True, skipped=True)
+
     try:
         dest, dl_ok = fut.result()
     except Exception as e:
@@ -283,6 +312,8 @@ def _process_completed(
     t0 = time.monotonic()
     ok, err, reboot = _install_driver(driver, dest, cfg)
     dur = int((time.monotonic() - t0) * 1000)
+    if ok:
+        _record_installed(driver, idx)   # update live index so same-family dupes skip
     tag = " (reboot required)" if reboot else ""
     line = f"  {'✓' if ok else '✗'} [{cat}] {bid}  ({dur}ms){tag}"
     emit = events.ok if ok else events.error
@@ -292,6 +323,20 @@ def _process_completed(
                         duration_ms=dur, reboot_required=reboot)
 
 
+def _record_installed(driver: dict, idx: dict) -> None:
+    """Fold a just-installed driver's INF(s)+version into the live store index, so a
+    later package of the same driver family at an equal-or-older version is skipped
+    this pass — mirrors what `pnputil /enum-drivers` will report on the next scan."""
+    ver = _parse_ver(driver.get("version_label", ""))
+    if not ver:
+        return
+    for f in driver.get("files", []):
+        name = f.get("filename", "").lower()
+        if f.get("file_role") == "inf" or name.endswith(".inf"):
+            if idx.get(name) is None or ver > idx[name]:
+                idx[name] = ver
+
+
 def _download_driver(driver: dict, base: Path, repo_url: str,
                      cfg: dict) -> tuple[Path, bool]:
     """Download all files for one driver. Returns (dest_dir, success)."""