driverclient 0.2.21__tar.gz → 0.2.23__tar.gz

{driverclient-0.2.21 → driverclient-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.21
+Version: 0.2.23
 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.21 → driverclient-0.2.23}/pyproject.toml

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

{driverclient-0.2.21 → driverclient-0.2.23}/src/driverclient/__init__.py

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

{driverclient-0.2.21 → driverclient-0.2.23}/src/driverclient/ops/install.py

@@ -26,9 +26,11 @@ from pathlib import Path
 from driverclient import events
 from driverclient.config import get
 from driverclient.core import proc
+from driverclient.core import hwid as hwid_mod
 from driverclient.core.http import http_post_retry
 from driverclient.ops.download import download_driver
 from driverclient.ops.resolve import ResolveResult, resolve
+from driverclient.ops.scan import scan
 
 # Install order: lower number first (hardware dependency)
 _CATEGORY_ORDER: dict[str, int] = {
@@ -167,9 +169,11 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     idx: dict = _installed_inf_index() if skip_installed else {}
 
     drivers = result.drivers
+    already_in_store: list[dict] = []
     if skip_installed:
+        already_in_store = [d for d in drivers if _already_in_store(d, idx)]
         kept = [d for d in drivers if not _already_in_store(d, idx)]
-        skipped = len(drivers) - len(kept)
+        skipped = len(already_in_store)
         if skipped:
             events.progress(
                 "install",
@@ -178,6 +182,15 @@ def resolve_and_install(force: bool = False) -> InstallResult:
             )
         drivers = kept
         if not drivers:
+            # A display driver can be sitting in the store (e.g. staged offline
+            # via DISM during imaging) without ever being BOUND to the device —
+            # the primary adapter doesn't reliably switch itself over. Refresh it
+            # now instead of leaving that gap for Windows Update to close later.
+            _refresh_bound_devices(
+                already_in_store,
+                {(d.get("binding_id") or d.get("package_id", "")) for d in already_in_store},
+                cfg,
+            )
             events.done("install",
                         "[install] Nothing to install — all resolved drivers already current",
                         total=0)
@@ -201,6 +214,16 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # Skipped drivers ARE satisfied on the machine — report them upstream as success.
     _confirm(result.trace_id, installed_ok + skipped_now, install_failed, cfg)
 
+    # Force-bind any display driver now confirmed in the store — freshly
+    # installed here, or already present from an earlier offline/DISM pass —
+    # so the device actually switches over instead of staying on whatever it
+    # booted with until Windows Update eventually forces a real reinstall.
+    ready_ids = (
+        {r.binding_id for r in installed_ok}
+        | {(d.get("binding_id") or d.get("package_id", "")) for d in already_in_store}
+    )
+    _refresh_bound_devices(result.drivers, ready_ids, 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 ""
@@ -209,7 +232,7 @@ def resolve_and_install(force: bool = False) -> InstallResult:
                 total=len(all_results), ok=len(installed_ok), failed=len(install_failed),
                 skipped=len(skipped_now), reboot_required=reboot_required)
     for r in install_failed:
-        events.error("install", f"  ✗ {r.binding_id}: {r.error}",
+        events.error("install", f"  [x] {r.binding_id}: {r.error}",
                      binding_id=r.binding_id, error=r.error)
 
     return InstallResult(
@@ -330,7 +353,7 @@ def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
     tag = " (reboot required)" if reboot else ""
     (events.ok if ok else events.error)(
         "install",
-        f"  {'✓' if ok else '✗'} batch-installed {n} INF driver(s) ({dur}ms){tag}",
+        f"  {'[ok]' if ok else '[x]'} batch-installed {n} INF driver(s) ({dur}ms){tag}",
         count=n, duration_ms=dur, reboot_required=reboot, error=err)
 
     return [
@@ -359,7 +382,7 @@ def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
         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)",
+        "install", f"  {'[ok]' if ok else '[x]'} [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)
@@ -369,6 +392,59 @@ def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
 # the offline / pre-boot path.
 
 
+# ── Device refresh (force-bind display drivers) ─────────────────────────────────
+
+def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict) -> None:
+    """Force Windows to actually bind a display driver that's confirmed in the
+    driver store (just installed, or already there from an earlier offline/DISM
+    injection) but not necessarily applied to the device yet.
+
+    pnputil only stages a package into the store — the primary display adapter
+    is already rendering the current session with whatever driver it booted
+    with and doesn't reliably re-evaluate/switch itself over on its own. Left
+    alone, the device stays on the fallback driver until something forces a
+    real reinstall — which is what Windows' own automatic Windows Update
+    driver search eventually does, closing the gap our own pipeline left open.
+    Disabling + re-enabling the device here forces Windows to redo PnP install
+    for it immediately, picking up the driver that's already in the store.
+    """
+    display_hwids = {
+        d["hwid"] for d in drivers
+        if d.get("category") == "display" and d.get("hwid")
+        and (d.get("binding_id") or d.get("package_id", "")) in ready_ids
+    }
+    if not display_hwids:
+        return
+
+    canon_targets = {hwid_mod.canonicalize(h) for h in display_hwids}
+    scan_result = scan(force=False)
+    for dev in scan_result.devices:
+        if any(hwid_mod.canonicalize(h) in canon_targets for h in dev.hwids):
+            _refresh_device(dev.instance_id, cfg)
+
+
+def _refresh_device(instance_id: str, cfg: dict) -> None:
+    """Disable then re-enable one device by instance ID — forces Windows to redo
+    PnP install for it, so a driver already in the store but not yet bound
+    takes effect immediately, without a reboot."""
+    events.progress("install",
+                    f"[install] Refreshing device to bind new driver: {instance_id}",
+                    instance_id=instance_id)
+    timeout = cfg.get("timeout_short", 30)
+    try:
+        proc.run(["pnputil", "/disable-device", instance_id],
+                 capture_output=True, text=True, timeout=timeout)
+        r = proc.run(["pnputil", "/enable-device", instance_id],
+                     capture_output=True, text=True, timeout=timeout)
+        ok = r.returncode == 0
+        (events.ok if ok else events.error)(
+            "install", f"  {'[ok]' if ok else '[x]'} refreshed {instance_id}",
+            instance_id=instance_id, error="" if ok else r.stdout.strip()[:200])
+    except Exception as e:
+        events.error("install", f"  [x] refresh failed for {instance_id}: {e}",
+                     instance_id=instance_id, error=str(e))
+
+
 # ── Driver installation ─────────────────────────────────────────────────────────
 
 def _classify(returncode: int, stdout: str = "", stderr: str = "") -> tuple[bool, str, bool]:

{driverclient-0.2.21 → driverclient-0.2.23}/src/driverclient/ops/offline.py

@@ -70,7 +70,7 @@ def resolve_and_download() -> OfflineResult:
 
     drivers = result.drivers
     events.start("offline",
-                 f"[offline] {len(drivers)} driver(s) → downloading to {target} …",
+                 f"[offline] {len(drivers)} driver(s) -> downloading to {target} ...",
                  total=len(drivers))
 
     downloaded = download_drivers(drivers, target, cfg)
@@ -82,12 +82,12 @@ def resolve_and_download() -> OfflineResult:
         (ok if success else failed).append(bid)
 
     for bid in failed:
-        events.error("offline", f"  ✗ {bid}: download_failed", binding_id=bid)
+        events.error("offline", f"  [x] {bid}: download_failed", binding_id=bid)
 
     events.done(
         "offline",
-        f"[offline] Done — {len(ok)} downloaded  {len(failed)} failed  "
-        f"→ {target}  (DISM injects offline next)",
+        f"[offline] Done - {len(ok)} downloaded  {len(failed)} failed  "
+        f"-> {target}  (DISM injects offline next)",
         total=len(downloaded), ok=len(ok), failed=len(failed),
         target_dir=str(target),
     )

{driverclient-0.2.21 → driverclient-0.2.23}/src/driverclient/ops/scan.py

@@ -369,7 +369,7 @@ def _print_summary(r: ScanResult) -> None:
         events.progress("scan", "[scan] Missing drivers:")
         for d in r.missing_driver:
             name = _device_label(d)
-            events.progress("scan", f"  ✗  {name}",
+            events.progress("scan", f"  [x] {name}",
                             device_name=name, class_name=d.class_name)