driverclient 0.2.29__tar.gz → 0.2.30__tar.gz

{driverclient-0.2.29 → driverclient-0.2.30}/PKG-INFO

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

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

{driverclient-0.2.29 → driverclient-0.2.30}/src/driverclient/__init__.py

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

{driverclient-0.2.29 → driverclient-0.2.30}/src/driverclient/ops/capture.py

@@ -97,6 +97,9 @@ def _machine_meta() -> dict:
         "machine_id": machine_id,
     }
 
+
+_WINDOWS_INF = Path("C:\\Windows\\INF")
+
 _PNPUTIL_KEYS: dict[str, str] = {
     "published name": "published_name",
     "original name": "original_name",
@@ -346,13 +349,12 @@ def wu_update(force: bool = False) -> CaptureResult:
         **skip_reasons,
     )
 
-    baseline = _snapshot_published_names(cfg)
     trigger = _trigger_wu()
     if trigger is None:
         return CaptureResult(still_missing=len(wu_hwids))
 
     wu_start = datetime.now(timezone.utc)
-    total = _poll_and_submit_incremental(wu_start, cfg, trigger, baseline)
+    total = _poll_and_submit_incremental(wu_start, cfg, trigger)
     total.wu_triggered = True
     total.still_missing = max(0, len(wu_hwids) - total.submitted)
     total.reboot_required = _wu_reboot_pending()
@@ -381,13 +383,12 @@ def wu_full() -> CaptureResult:
         "windows_update", "[wu-full] Triggering full Windows Update scan (no HWID filtering)…"
     )
 
-    baseline = _snapshot_published_names(cfg)
     trigger = _trigger_wu()
     if trigger is None:
         return CaptureResult()
 
     wu_start = datetime.now(timezone.utc)
-    total = _poll_and_submit_incremental(wu_start, cfg, trigger, baseline)
+    total = _poll_and_submit_incremental(wu_start, cfg, trigger)
     total.wu_triggered = True
     _post_wu_session(cfg, wu_start, [], total.submitted)
     events.done(
@@ -403,22 +404,12 @@ 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).
-
-    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.
-    """
+    candidate), unknown (HWID not in scan)."""
     hwid_to_device: dict[str, Device] = {}
     for scanned in scan_result.devices:
         for h in scanned.hwids:
@@ -436,10 +427,8 @@ 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 and dev.class_name.lower() not in _INBOX_INADEQUATE_CLASSES:
-            buckets["inbox"].append(hwid)
         elif dev.is_inbox:
-            buckets["driverless"].append(hwid)
+            buckets["inbox"].append(hwid)
         else:
             buckets["oem_local"].append(hwid)
     return buckets
@@ -527,25 +516,17 @@ def _parse_enum_drivers(output: str) -> list[dict]:
     return packages
 
 
-def _snapshot_published_names(cfg: dict) -> set[str]:
-    """Published names (oemNN.inf) already in the driver store — the baseline a
-    WU run's new-package detection diffs against. Must be taken BEFORE
-    triggering WU so nothing it installs is mistaken for pre-existing."""
-    return {p["published_name"] for p in _enumerate_all_packages(cfg) if p.get("published_name")}
-
-
-def _enumerate_new_packages(baseline: set[str], cfg: dict) -> list[dict]:
-    """Return packages present now that weren't in the pre-WU baseline.
-
-    Published names are assigned once by Windows and never reused while a
-    package stays in the store, so "not in baseline" is a robust new-package
-    signal. The previous approach compared each INF's mtime under
-    C:\\Windows\\INF against the WU start time — but that mtime can predate the
-    run (e.g. Windows already staged the file) or otherwise not bump the way
-    expected, silently dropping a genuinely new package (e.g. a discrete AMD
-    display driver landing via WU alongside an already-captured Intel one)
-    from ever being detected as new, so it was never submitted."""
-    return [p for p in _enumerate_all_packages(cfg) if p.get("published_name") not in baseline]
+def _enumerate_packages_since(cutoff: datetime, cfg: dict) -> list[dict]:
+    """Return packages whose C:\\Windows\\INF mtime >= cutoff."""
+    result = []
+    for pkg in _enumerate_all_packages(cfg):
+        inf_path = _WINDOWS_INF / pkg["published_name"]
+        if not inf_path.exists():
+            continue
+        mtime = datetime.fromtimestamp(inf_path.stat().st_mtime, tz=timezone.utc)
+        if mtime >= cutoff:
+            result.append(pkg)
+    return result
 
 
 def _published_names_for_hwids(
@@ -885,7 +866,7 @@ def _drain_wu_log(trigger: "_WuTrigger | None", pos: int) -> int:
 
 
 def _poll_and_submit_incremental(
-    wu_start: datetime, cfg: dict, trigger: "_WuTrigger | None", baseline: set[str]
+    wu_start: datetime, cfg: dict, trigger: "_WuTrigger | None"
 ) -> CaptureResult:
     """
     Wait on Windows Update, submitting each new DriverStore package as it lands.
@@ -920,7 +901,7 @@ def _poll_and_submit_incremental(
 
     while datetime.now(timezone.utc) < deadline:
         log_pos = _drain_wu_log(trigger, log_pos)  # surface WU's live phase
-        all_new = _enumerate_new_packages(baseline, cfg)
+        all_new = _enumerate_packages_since(wu_start, cfg)
         new_batch = [p for p in all_new if p.get("published_name", "") not in seen]
 
         if new_batch:

{driverclient-0.2.29 → driverclient-0.2.30}/src/driverclient/ops/download.py

@@ -12,6 +12,7 @@ Factored out here so the two modes share one download implementation:
   • download_drivers() — fan the above out across a driver list in parallel
 """
 
+import shutil
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
@@ -20,7 +21,21 @@ from driverclient.core.http import http_download_retry
 
 def download_driver(driver: dict, base: Path, repo_url: str, cfg: dict) -> tuple[Path, bool]:
     """Download all files for one driver into base/<binding_id>/.
-    Returns (dest_dir, success). success is False if ANY file failed."""
+    Returns (dest_dir, success). success is False if ANY file failed.
+
+    On failure, dest is removed before returning. The live install path stages
+    every driver under one shared `base` and installs it with a single batched
+    `pnputil /add-driver base\\*.inf /subdirs` — that command globs the
+    filesystem directly, so a driver this function reports as failed (and the
+    caller correctly excludes from the install list) would otherwise still
+    leave its already-downloaded files (commonly just the small .inf, if a
+    large companion .sys/.dll timed out) sitting under base/<binding_id>/ for
+    pnputil to find anyway. pnputil then tries to add that incomplete package —
+    "cannot find the file specified" for its missing payload — which large
+    graphics drivers hit most often (biggest files, likeliest to time out
+    partway), and can poison the whole batched pass for the OTHER, fully
+    downloaded drivers riding in the same pnputil call.
+    """
     bid = driver.get("binding_id") or driver.get("package_id", "")
     pkg_id = driver["package_id"]
     dest = base / bid
@@ -36,6 +51,9 @@ def download_driver(driver: dict, base: Path, repo_url: str, cfg: dict) -> tuple
         if not http_download_retry(url, path, f["sha256"], timeout=cfg["timeout_long"]):
             ok = False
 
+    if not ok:
+        shutil.rmtree(dest, ignore_errors=True)
+
     return dest, ok