driverclient 0.2.18__tar.gz → 0.2.20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.18
+Version: 0.2.20
 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.20}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "driverclient"
-version = "0.2.18"
+version = "0.2.20"
 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.20}/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.20"
 
 
 class DriverClient:

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

@@ -19,7 +19,7 @@ import subprocess
 import time
 import uuid
 from collections import defaultdict
-from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -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,18 @@ 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.
+    # Driver-store index (INF name -> highest installed version), built once to
+    # FILTER the download list: skip any package the store already has at the
+    # same-or-newer version. This is skip-if-present (idempotency), NOT dedup —
+    # no repo package is removed; a newer repo version still installs over an
+    # older store version (store_ver >= repo_ver skips). Duplicate versions that
+    # survive the filter are resolved at install time by a single batched pnputil
+    # pass, where Windows picks the best driver per device.
+    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:
@@ -183,17 +193,20 @@ def resolve_and_install(force: bool = False) -> InstallResult:
 
     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)
@@ -209,26 +222,57 @@ def resolve_and_install(force: bool = False) -> InstallResult:
 
 def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverResult]:
     """
-    Submit ALL downloads (all levels) simultaneously, then install level-by-level.
-    Each driver installs the moment its own download Future completes.
+    Download every driver in parallel, then install in the fewest passes possible:
+
+      • all INF drivers  -> ONE `pnputil /add-driver <base>\\*.inf /subdirs /install`
+        pass. Windows stages every package and installs the best/newest driver per
+        device in a single PnP reconciliation — far faster than one pnputil call
+        per driver, and it resolves duplicate versions itself (so "no dedup" is
+        handled at install time here, not by dropping packages).
+      • EXE-installer drivers -> run their silent installer individually (EXEs
+        cannot be batched).
+
+    Downloads stay fully parallel; only the install strategy changed from one
+    pnputil call per driver to a single batched call.
     """
     repo_url = cfg["local_repo_url"]
     parallel = cfg.get("parallel_downloads", 6)
 
-    by_level                 = _dedup_and_group(drivers)
-    executor                 = ThreadPoolExecutor(max_workers=parallel)
-    future_info, level_futs  = _submit_all_downloads(by_level, base, repo_url, cfg, executor)
-
-    all_results: list[DriverResult] = []
-    for level in sorted(by_level):
-        events.progress("install",
-                        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))
-
-    executor.shutdown(wait=False)
-    return all_results
+    by_level = _dedup_and_group(drivers)
+    ordered  = [d for level in sorted(by_level) for d in by_level[level]]
+
+    events.progress("install",
+                    f"[install] Downloading {len(ordered)} driver(s) in parallel…",
+                    total=len(ordered))
+
+    results:    list[DriverResult]      = []
+    downloaded: list[tuple[dict, Path]] = []
+    with ThreadPoolExecutor(max_workers=parallel) as executor:
+        fut_map = {executor.submit(_download_driver, d, base, repo_url, cfg): d
+                   for d in ordered}
+        for fut in as_completed(fut_map):
+            driver = fut_map[fut]
+            bid    = driver.get("binding_id") or driver.get("package_id", "")
+            try:
+                dest, dl_ok = fut.result()
+            except Exception as e:
+                results.append(DriverResult(binding_id=bid, success=False, error=str(e)))
+                continue
+            if dl_ok:
+                downloaded.append((driver, dest))
+            else:
+                results.append(DriverResult(binding_id=bid, success=False,
+                                            error="download_failed"))
+
+    inf_drivers = [(d, p) for d, p in downloaded
+                   if d.get("install_type", "inf_silent") != "exe_silent"]
+    exe_drivers = [(d, p) for d, p in downloaded
+                   if d.get("install_type", "inf_silent") == "exe_silent"]
+
+    results += _batch_install_infs(inf_drivers, base, cfg)
+    for driver, dest in exe_drivers:
+        results.append(_install_one_exe(driver, dest, cfg))
+    return results
 
 
 def _dedup_and_group(drivers: list[dict]) -> dict[int, list[dict]]:
@@ -244,50 +288,78 @@ def _dedup_and_group(drivers: list[dict]) -> dict[int, list[dict]]:
     return by_level
 
 
-def _submit_all_downloads(
-    by_level: dict[int, list[dict]],
-    base: Path,
-    repo_url: str,
-    cfg: dict,
-    executor: ThreadPoolExecutor,
-) -> tuple[dict[Future, tuple[int, dict]], dict[int, list[Future]]]:
-    """Submit every driver download to the pool at once. Returns lookup maps."""
-    future_info:  dict[Future, tuple[int, dict]] = {}
-    level_futs:   dict[int, list[Future]]        = defaultdict(list)
-    for level in sorted(by_level):
-        for driver in by_level[level]:
-            fut = executor.submit(_download_driver, driver, base, repo_url, cfg)
-            future_info[fut] = (level, driver)
-            level_futs[level].append(fut)
-    return future_info, level_futs
-
-
-def _process_completed(
-    fut: Future,
-    future_info: dict[Future, tuple[int, dict]],
-    cfg: dict,
-) -> 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")
-
+def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
+                        cfg: dict) -> list[DriverResult]:
+    """Install every downloaded INF driver in ONE pnputil pass.
+
+    `pnputil /add-driver <base>\\*.inf /subdirs /install` recurses the staging tree
+    (each driver lives in its own subdir), adds every package to the driver store
+    and installs the best match onto each device in a single PnP reconciliation —
+    the fast path the old driverserver used (launcher.bat). pnputil does not report
+    a clean per-package status, so the batch's outcome is attributed to each driver
+    and pnputil's own output lines are surfaced so nothing is hidden by batching."""
+    if not inf_drivers:
+        return []
+
+    n = len(inf_drivers)
+    events.progress("install",
+                    f"[install] Installing {n} INF driver(s) in one batched pnputil pass…",
+                    total=n)
+    t0     = time.monotonic()
+    stdout = ""
     try:
-        dest, dl_ok = fut.result()
+        r = proc.run(
+            ["pnputil", "/add-driver", str(base / "*.inf"), "/subdirs", "/install"],
+            capture_output=True, text=True,
+            timeout=cfg.get("timeout_install", 600),
+        )
+        stdout = r.stdout or ""
+        ok, err, reboot = _classify(r.returncode, r.stdout, r.stderr)
+    except subprocess.TimeoutExpired:
+        ok, err, reboot = False, "Batch install timed out", False
     except Exception as e:
-        return DriverResult(binding_id=bid, success=False, error=str(e))
+        ok, err, reboot = False, str(e), False
+    dur = int((time.monotonic() - t0) * 1000)
 
-    if not dl_ok:
-        return DriverResult(binding_id=bid, success=False, error="download_failed")
+    for line in stdout.splitlines():
+        s = line.strip()
+        if s:
+            events.progress("install", f"    {s}")
 
-    t0 = time.monotonic()
-    ok, err, reboot = _install_driver(driver, dest, cfg)
-    dur = int((time.monotonic() - t0) * 1000)
     tag = " (reboot required)" if reboot else ""
-    line = f"  {'✓' if ok else '✗'} [{cat}] {bid}  ({dur}ms){tag}"
-    emit = events.ok if ok else events.error
-    emit("install", line, binding_id=bid, category=cat, duration_ms=dur,
-         error=err, reboot_required=reboot)
+    (events.ok if ok else events.error)(
+        "install",
+        f"  {'✓' if ok else '✗'} batch-installed {n} INF driver(s) ({dur}ms){tag}",
+        count=n, duration_ms=dur, reboot_required=reboot, error=err)
+
+    return [
+        DriverResult(binding_id=(d.get("binding_id") or d.get("package_id", "")),
+                     success=ok, error="" if ok else err,
+                     duration_ms=dur, reboot_required=reboot)
+        for d, _ in inf_drivers
+    ]
+
+
+def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
+    """Run one EXE-installer driver's silent setup (EXEs cannot be batched)."""
+    bid = driver.get("binding_id") or driver.get("package_id", "")
+    t0  = time.monotonic()
+    try:
+        exe_files = list(driver_dir.glob("*.exe"))
+        if not exe_files:
+            return DriverResult(binding_id=bid, success=False, error="No EXE file found")
+        flags = driver.get("install_flags", "/S")
+        r = proc.run([str(exe_files[0])] + flags.split(),
+                     capture_output=True, timeout=cfg["timeout_install"])
+        ok, err, reboot = _classify(r.returncode)
+    except subprocess.TimeoutExpired:
+        ok, err, reboot = False, "Install timed out", False
+    except Exception as e:
+        ok, err, reboot = False, str(e), False
+    dur = int((time.monotonic() - t0) * 1000)
+    (events.ok if ok else events.error)(
+        "install", f"  {'✓' if ok else '✗'} [exe] {bid} ({dur}ms)",
+        binding_id=bid, duration_ms=dur, error=err, reboot_required=reboot)
     return DriverResult(binding_id=bid, success=ok, error=err,
                         duration_ms=dur, reboot_required=reboot)
 
@@ -311,12 +383,6 @@ def _download_driver(driver: dict, base: Path, repo_url: str,
     return dest, ok
 
 
-def _level_label(level: int) -> str:
-    labels = {0: "chipset", 1: "firmware", 2: "storage",
-              3: "network", 5: "display", 6: "audio", 10: "other"}
-    return labels.get(level, f"level-{level}")
-
-
 # ── Driver installation ─────────────────────────────────────────────────────────
 
 def _classify(returncode: int, stdout: str = "", stderr: str = "") -> tuple[bool, str, bool]:
@@ -352,52 +418,6 @@ def _classify(returncode: int, stdout: str = "", stderr: str = "") -> tuple[bool
     return False, (stderr.strip() or stdout.strip() or f"exit {returncode}")[:200], False
 
 
-def _install_driver(driver: dict, driver_dir: Path, cfg: dict) -> tuple[bool, str, bool]:
-    install_type = driver.get("install_type", "inf_silent")
-
-    try:
-        if install_type == "inf_silent":
-            inf_files = list(driver_dir.glob("*.inf"))
-            if not inf_files:
-                return False, "No INF file found", False
-            r = proc.run(
-                ["pnputil", "/add-driver", str(inf_files[0]), "/install", "/subdirs"],
-                capture_output=True, text=True,
-                timeout=cfg["timeout_long"],
-            )
-            return _classify(r.returncode, r.stdout, r.stderr)
-
-        if install_type == "exe_silent":
-            exe_files = list(driver_dir.glob("*.exe"))
-            if not exe_files:
-                return False, "No EXE file found", False
-            flags = driver.get("install_flags", "/S")
-            r = proc.run(
-                [str(exe_files[0])] + flags.split(),
-                capture_output=True,
-                timeout=cfg["timeout_install"],
-            )
-            return _classify(r.returncode)
-
-        if install_type == "firmware_flash":
-            inf_files = list(driver_dir.glob("*.inf"))
-            if not inf_files:
-                return False, "No firmware INF", False
-            r = proc.run(
-                ["pnputil", "/add-driver", str(inf_files[0]), "/install"],
-                capture_output=True, text=True,
-                timeout=cfg["timeout_long"],
-            )
-            return _classify(r.returncode, r.stdout, r.stderr)
-
-    except subprocess.TimeoutExpired:
-        return False, "Install timed out", False
-    except Exception as e:
-        return False, str(e), False
-
-    return False, f"Unknown install_type: {install_type}", False
-
-
 # ── Confirm ─────────────────────────────────────────────────────────────────────
 
 def _confirm(trace_id: str, ok: list[DriverResult], fail: list[DriverResult],