driverclient 0.2.31__tar.gz → 0.2.32__tar.gz

{driverclient-0.2.31 → driverclient-0.2.32}/PKG-INFO

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

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

{driverclient-0.2.31 → driverclient-0.2.32}/src/driverclient/__init__.py

@@ -26,7 +26,7 @@ from driverclient.main import run as _run
 
 __all__ = ["ClientEvent", "DriverClient"]
 
-__version__ = "0.2.31"
+__version__ = "0.2.32"
 
 
 class DriverClient:

{driverclient-0.2.31 → driverclient-0.2.32}/src/driverclient/ops/capture.py

@@ -404,12 +404,22 @@ def wu_full() -> CaptureResult:
 
 # ══ Missing-HWID classification ═══════════════════════════════════════════════
 
+_INBOX_INADEQUATE_CLASSES = {"display adapters"}
+
 
 def classify_missing(not_found: list[str], scan_result: ScanResult) -> dict[str, list[str]]:
     """Bucket repo-missing HWIDs by what the machine says about their device:
     inbox (Windows ships the driver — not applicable), oem_local (OEM driver
     installed locally — capturable), driverless (genuinely missing — WU
-    candidate), unknown (HWID not in scan)."""
+    candidate), unknown (HWID not in scan).
+
+    Display adapters are excluded from the inbox bucket: Microsoft Basic
+    Display Adapter is Windows' inbox fallback for a GPU whose real driver
+    was never bound, and it leaves the device non-accelerated — unlike other
+    inbox drivers (HID, mass storage, ...) it is not adequate coverage. Such
+    a device is treated as driverless so it still reaches WU / gets captured
+    once a real driver shows up, instead of being silently written off.
+    """
     hwid_to_device: dict[str, Device] = {}
     for scanned in scan_result.devices:
         for h in scanned.hwids:
@@ -427,8 +437,10 @@ def classify_missing(not_found: list[str], scan_result: ScanResult) -> dict[str,
             buckets["unknown"].append(hwid)
         elif not dev.has_driver:
             buckets["driverless"].append(hwid)
-        elif dev.is_inbox:
+        elif dev.is_inbox and dev.class_name.lower() not in _INBOX_INADEQUATE_CLASSES:
             buckets["inbox"].append(hwid)
+        elif dev.is_inbox:
+            buckets["driverless"].append(hwid)
         else:
             buckets["oem_local"].append(hwid)
     return buckets

{driverclient-0.2.31 → driverclient-0.2.32}/src/driverclient/ops/install.py

@@ -90,6 +90,13 @@ class InstallResult:
     installed_ok: list[DriverResult] = field(default_factory=list)
     install_failed: list[DriverResult] = field(default_factory=list)
     trace_id: str = ""
+    # A display driver is confirmed in the driver store but the device is STILL
+    # bound to an inbox/Basic Display driver after the disable/enable refresh —
+    # display drivers often need a reboot to actually bind. Set by
+    # _refresh_bound_devices so the orchestrator reboots (once) to let it bind,
+    # instead of silently leaving the device on Basic Display and falling back
+    # to Windows Update.
+    rebind_reboot: bool = False
 
     @property
     def ok_count(self) -> int:
@@ -101,8 +108,9 @@ class InstallResult:
 
     @property
     def reboot_required(self) -> bool:
-        """True if any successfully-installed driver reported reboot-required."""
-        return any(r.reboot_required for r in self.installed_ok)
+        """True if a successfully-installed driver reported reboot-required, or a
+        display device is still on Basic Display and needs a reboot to bind."""
+        return self.rebind_reboot or any(r.reboot_required for r in self.installed_ok)
 
 
 def _parse_ver(s: str) -> tuple | None:
@@ -203,17 +211,19 @@ def resolve_and_install(force: bool = False) -> InstallResult:
             # 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(
+            rebind_reboot = _refresh_bound_devices(
                 already_in_store,
                 {_bid(d) for d in already_in_store},
                 cfg,
             )
             events.done(
                 "install",
-                "[install] Nothing to install — all resolved drivers already current",
+                "[install] Nothing to install — all resolved drivers already current"
+                + ("  — reboot required to bind display" if rebind_reboot else ""),
                 total=0,
+                reboot_required=rebind_reboot,
             )
-            return InstallResult(trace_id=result.trace_id)
+            return InstallResult(trace_id=result.trace_id, rebind_reboot=rebind_reboot)
 
     session_id = str(uuid.uuid4())
     work_dir = Path(cfg.get("work_dir", "C:\\DriverServer\\client\\staging")) / session_id
@@ -240,9 +250,9 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # 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} | {_bid(d) for d in already_in_store}
-    _refresh_bound_devices(result.drivers, ready_ids, cfg)
+    rebind_reboot = _refresh_bound_devices(result.drivers, ready_ids, cfg)
 
-    reboot_required = any(r.reboot_required for r in installed_ok)
+    reboot_required = rebind_reboot or 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(
@@ -263,6 +273,7 @@ def resolve_and_install(force: bool = False) -> InstallResult:
         installed_ok=installed_ok,
         install_failed=install_failed,
         trace_id=result.trace_id,
+        rebind_reboot=rebind_reboot,
     )
 
 
@@ -439,7 +450,7 @@ def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
 # ── Device refresh (force-bind display drivers) ─────────────────────────────────
 
 
-def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict) -> None:
+def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict) -> bool:
     """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.
@@ -452,6 +463,18 @@ def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict)
     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.
+
+    After refreshing, a FRESH scan verifies each target device actually left the
+    inbox/Basic Display driver and is now on its OEM (oemNN.inf) driver. A
+    display driver frequently needs a reboot to bind — disable/enable alone
+    doesn't always switch the primary adapter over — so any device still on an
+    inbox driver is reported loudly and this returns True, telling the caller a
+    reboot is needed. That is far better than the old silent success, which left
+    the device on Basic Display and pushed the machine into the slow Windows
+    Update path on every deployment.
+
+    Returns True when at least one target display device is still bound to an
+    inbox driver after the refresh (→ reboot required to bind); False otherwise.
     """
     display_hwids = {
         d["hwid"]
@@ -459,13 +482,44 @@ def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict)
         if d.get("category") == "display" and d.get("hwid") and _bid(d) in ready_ids
     }
     if not display_hwids:
-        return
+        return False
 
     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)
+    # force=True: we just installed/staged drivers, so a cached scan would be stale.
+    scan_result = scan(force=True)
+    targets = [
+        dev
+        for dev in scan_result.devices
+        if any(hwid_mod.canonicalize(h) in canon_targets for h in dev.hwids)
+    ]
+    if not targets:
+        return False
+
+    for dev in targets:
+        _refresh_device(dev.instance_id, cfg)
+
+    # Verify the refresh actually switched each device off its inbox/Basic
+    # Display fallback onto the OEM driver now in the store.
+    verify = scan(force=True)
+    by_instance = {d.instance_id: d for d in verify.devices}
+    still_inbox = []
+    for dev in targets:
+        cur = by_instance.get(dev.instance_id)
+        # No longer present (rare) is treated as "resolved"; still on an inbox
+        # driver (or no driver at all) means the OEM driver did not take.
+        if cur is not None and (not cur.has_driver or cur.is_inbox):
+            still_inbox.append(cur)
+
+    for dev in still_inbox:
+        label = dev.device_name or dev.instance_id
+        events.warn(
+            "install",
+            f"[install] Display device still on inbox/Basic Display after refresh: "
+            f"{label} (now: {dev.driver_name or 'no driver'}) — will reboot to bind",
+            instance_id=dev.instance_id,
+            driver_name=dev.driver_name,
+        )
+    return bool(still_inbox)
 
 
 def _refresh_device(instance_id: str, cfg: dict) -> None: