driverclient 0.2.25__tar.gz → 0.2.27__tar.gz

{driverclient-0.2.25 → driverclient-0.2.27}/PKG-INFO

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

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

{driverclient-0.2.25 → driverclient-0.2.27}/src/driverclient/__init__.py

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

{driverclient-0.2.25 → driverclient-0.2.27}/src/driverclient/ops/automate.py

@@ -18,7 +18,7 @@ from datetime import datetime, timezone
 from driverclient import events
 from driverclient.config import get
 from driverclient.ops.capture import CaptureResult, classify_missing, wu_update
-from driverclient.ops.install import DriverResult, InstallResult, resolve_and_install
+from driverclient.ops.install import DriverResult, InstallResult, _bid, resolve_and_install
 from driverclient.ops.resolve import ResolveResult, resolve
 from driverclient.ops.scan import ScanResult, scan
 
@@ -113,11 +113,6 @@ def _step(n: int, label: str) -> None:
                     step=n, label=label)
 
 
-def _bid(driver: dict) -> str:
-    """Stable identity for a repo driver entry (matches install's dedup key)."""
-    return driver.get("binding_id") or driver.get("package_id", "")
-
-
 def _merge_install(combined: InstallResult, inst: InstallResult) -> None:
     """Fold one pass's results into the running total, deduped by binding_id so a
     same-boot re-attempt of an already-recorded driver is not double-counted; a

{driverclient-0.2.25 → driverclient-0.2.27}/src/driverclient/ops/capture.py

@@ -344,11 +344,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 dev in scan_result.devices:
         for h in dev.hwids:
@@ -363,8 +374,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
@@ -1070,4 +1083,4 @@ def _upload_worker(upload_q: queue.Queue, counts: dict,
 # Extension selection was removed: capture now packs every file
 # pnputil /export-driver produces (see _do_export), so the dump_extensions /
 # dump_extensions_overrides config keys are no longer consulted — filtering by
-# extension is what caused incomplete packages (broken link D).
+# extension is what caused incomplete packages (broken link D).

{driverclient-0.2.25 → driverclient-0.2.27}/src/driverclient/ops/install.py

@@ -64,6 +64,12 @@ _PNPUTIL_SUCCESS_MARKERS: tuple[str, ...] = (
 )
 
 
+def _bid(driver: dict) -> str:
+    """Stable identity for a repo driver entry — binding_id, falling back to
+    package_id. Shared dedup key: also imported by ops/automate.py."""
+    return driver.get("binding_id") or driver.get("package_id", "")
+
+
 @dataclass
 class DriverResult:
     binding_id:      str
@@ -171,8 +177,9 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     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)]
+        kept = []
+        for d in drivers:
+            (already_in_store if _already_in_store(d, idx) else kept).append(d)
         skipped = len(already_in_store)
         if skipped:
             events.progress(
@@ -188,7 +195,7 @@ def resolve_and_install(force: bool = False) -> InstallResult:
             # 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},
+                {_bid(d) for d in already_in_store},
                 cfg,
             )
             events.done("install",
@@ -220,7 +227,7 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # 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}
+        | {_bid(d) for d in already_in_store}
     )
     _refresh_bound_devices(result.drivers, ready_ids, cfg)
 
@@ -276,7 +283,7 @@ def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverRe
                    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", "")
+            bid    = _bid(driver)
             try:
                 dest, dl_ok = fut.result()
             except Exception as e:
@@ -304,7 +311,7 @@ def _dedup_and_group(drivers: list[dict]) -> dict[int, list[dict]]:
     seen: set[str] = set()
     by_level: dict[int, list[dict]] = defaultdict(list)
     for d in drivers:
-        bid = d.get("binding_id") or d.get("package_id", "")
+        bid = _bid(d)
         if bid and bid not in seen:
             seen.add(bid)
             level = _CATEGORY_ORDER.get(d.get("category", "other"), 10)
@@ -357,7 +364,7 @@ def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
         count=n, duration_ms=dur, reboot_required=reboot, error=err)
 
     return [
-        DriverResult(binding_id=(d.get("binding_id") or d.get("package_id", "")),
+        DriverResult(binding_id=_bid(d),
                      success=ok, error="" if ok else err,
                      duration_ms=dur, reboot_required=reboot)
         for d, _ in inf_drivers
@@ -366,7 +373,7 @@ def _batch_install_infs(inf_drivers: list[tuple[dict, Path]], base: Path,
 
 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", "")
+    bid = _bid(driver)
     t0  = time.monotonic()
     try:
         exe_files = list(driver_dir.glob("*.exe"))
@@ -411,7 +418,7 @@ def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict)
     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
+        and _bid(d) in ready_ids
     }
     if not display_hwids:
         return
@@ -426,23 +433,61 @@ def _refresh_bound_devices(drivers: list[dict], ready_ids: set[str], cfg: dict)
 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."""
+    takes effect immediately, without a reboot.
+
+    A disable that succeeds but is never followed by a working re-enable is the
+    worst outcome here: unlike a failed install, a `pnputil /disable-device`
+    persists across reboot, so the device (the primary display adapter, in the
+    case this exists for) does not self-heal — it silently drops to Microsoft
+    Basic Display until someone notices and re-enables it by hand. So the
+    re-enable is attempted in `finally` regardless of how disable went (an
+    enable-device call on an already-enabled device is a harmless no-op),
+    retried a few times, and a persistent failure is escalated loudly rather
+    than swallowed.
+    """
     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],
+        r = proc.run(["pnputil", "/disable-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])
+        if r.returncode != 0:
+            events.warn("install",
+                        f"  [!] disable-device returned {r.returncode} for {instance_id}",
+                        instance_id=instance_id, error=r.stdout.strip()[:200])
     except Exception as e:
-        events.error("install", f"  [x] refresh failed for {instance_id}: {e}",
+        events.warn("install", f"  [!] disable-device raised for {instance_id}: {e}",
                      instance_id=instance_id, error=str(e))
+    finally:
+        ok, err = _enable_with_retries(instance_id, timeout)
+        if ok:
+            events.ok("install", f"  [ok] refreshed {instance_id}", instance_id=instance_id)
+        else:
+            events.error(
+                "install",
+                f"  [!!] CRITICAL: {instance_id} may be left DISABLED after refresh — "
+                f"run `pnputil /enable-device \"{instance_id}\"` manually to recover",
+                instance_id=instance_id, error=err, critical=True)
+
+
+def _enable_with_retries(instance_id: str, timeout: int, attempts: int = 3) -> tuple[bool, str]:
+    """Run `pnputil /enable-device`, retrying a couple of times before giving up —
+    a transient PnP busy state can fail the first attempt even though the device
+    would enable fine a moment later. Returns (success, last_error)."""
+    last_err = ""
+    for attempt in range(1, attempts + 1):
+        try:
+            r = proc.run(["pnputil", "/enable-device", instance_id],
+                         capture_output=True, text=True, timeout=timeout)
+            if r.returncode == 0:
+                return True, ""
+            last_err = r.stdout.strip()[:200]
+        except Exception as e:
+            last_err = str(e)
+        if attempt < attempts:
+            time.sleep(2)
+    return False, last_err
 
 
 # ── Driver installation ─────────────────────────────────────────────────────────