driverclient 0.2.2__tar.gz → 0.2.4__tar.gz

{driverclient-0.2.2 → driverclient-0.2.4}/PKG-INFO

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

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

{driverclient-0.2.2 → driverclient-0.2.4}/src/driverclient/__init__.py

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

{driverclient-0.2.2 → driverclient-0.2.4}/src/driverclient/ops/automate.py

@@ -17,7 +17,7 @@ from datetime import datetime, timezone
 
 from driverclient import events
 from driverclient.config import get
-from driverclient.ops.capture import CaptureResult, wu_update
+from driverclient.ops.capture import CaptureResult, classify_missing, wu_update
 from driverclient.ops.install import InstallResult, resolve_and_install
 from driverclient.ops.resolve import ResolveResult, resolve
 from driverclient.ops.scan import ScanResult, scan
@@ -116,22 +116,39 @@ def _summary(r: AutomateResult) -> None:
     inst   = r.install or InstallResult()
     wu     = r.wu      or CaptureResult()
 
+    # Bucket the repo-missing HWIDs so "not found" reads truthfully: inbox
+    # devices are covered by Windows itself, not missing from the repo.
+    buckets = None
+    if r.scan and r.resolve and r.resolve.not_found:
+        buckets = classify_missing(r.resolve.not_found, r.scan)
+
     events.done("done", "")
     events.done("done", "=" * 60)
     events.done("done", "  Summary")
     events.done("done", f"  Duration : {r.duration_s}s", duration_s=r.duration_s)
+    if r.resolve:
+        events.done("done",
+                    f"  Current  : {r.resolve.already_current} already current "
+                    f"(of {r.resolve.total_hwids} HWIDs)",
+                    already_current=r.resolve.already_current,
+                    total_hwids=r.resolve.total_hwids)
     events.done("done", f"  Installed: {inst.ok_count} ok  {inst.fail_count} failed",
                 installed_ok=inst.ok_count, installed_failed=inst.fail_count)
     if inst.reboot_required:
         events.done("done", "  Reboot   : REQUIRED (a driver needs a reboot to take effect)",
                     reboot_required=True)
+    if buckets:
+        inbox = len(buckets["inbox"])
+        genuine = len(buckets["driverless"]) + len(buckets["unknown"])
+        if inbox:
+            events.done("done",
+                        f"  Inbox    : {inbox} HWID(s) — Windows inbox driver, not applicable",
+                        inbox=inbox)
+        events.done("done",
+                    f"  Missing  : {genuine} genuinely missing (WU candidates)",
+                    genuinely_missing=genuine)
     if r.wu and r.wu.wu_triggered:
         events.done("done",
                     f"  WU       : {wu.submitted} captured  {wu.still_missing} still missing",
                     wu_submitted=wu.submitted, wu_still_missing=wu.still_missing)
-    else:
-        missing = len(r.resolve.not_found) if r.resolve else 0
-        if missing:
-            events.done("done", f"  Missing  : {missing} HWID(s) not in repo (WU not run)",
-                        missing=missing)
     events.done("done", "=" * 60)

{driverclient-0.2.2 → driverclient-0.2.4}/src/driverclient/ops/capture.py

@@ -40,7 +40,7 @@ from driverclient.config import get
 from driverclient.core.hardware import compute_fingerprint, get_model_profile
 from driverclient.core.http import BadRequestError, http_post_retry, http_upload_package, pack_driver_archive
 from driverclient.ops.resolve import ResolveResult, resolve
-from driverclient.ops.scan import Device, ScanResult, scan
+from driverclient.ops.scan import Device, ScanResult, _looks_like_hwid, scan
 
 
 def _post_wu_session(cfg: dict, wu_start, hwids_tried: list, captured: int) -> None:
@@ -153,26 +153,35 @@ def capture_missing(force: bool = False) -> CaptureResult:
                     total=0)
         return CaptureResult()
 
-    not_found_set = set(res_result.not_found)
-    events.progress("capture",
-                    f"[capture-missing] {len(not_found_set)} HWID(s) missing from repo",
-                    total=len(not_found_set))
-
-    to_export = _find_installed_packages_for_hwids(not_found_set, scan_result, cfg)
+    buckets = classify_missing(res_result.not_found, scan_result)
+    genuinely_missing = len(buckets["driverless"]) + len(buckets["unknown"])
+    events.progress(
+        "capture",
+        f"[capture-missing] {len(res_result.not_found)} HWID(s) not in repo — "
+        f"{len(buckets['inbox'])} inbox (not applicable)  "
+        f"{len(buckets['oem_local'])} with local OEM driver  "
+        f"{genuinely_missing} genuinely missing",
+        total=len(res_result.not_found), inbox=len(buckets["inbox"]),
+        oem_local=len(buckets["oem_local"]), genuinely_missing=genuinely_missing)
+
+    to_export = _find_installed_packages_for_hwids(set(buckets["oem_local"]), scan_result, cfg)
     if not to_export:
         events.done("capture",
-                    "[capture-missing] None of the missing HWIDs have locally-installed drivers",
-                    total=0, still_missing=len(not_found_set))
-        return CaptureResult(still_missing=len(not_found_set))
+                    f"[capture-missing] Nothing capturable — {len(buckets['inbox'])} inbox, "
+                    f"{genuinely_missing} genuinely missing (WU candidates)",
+                    total=0, still_missing=genuinely_missing)
+        return CaptureResult(still_missing=genuinely_missing)
 
     events.progress("capture",
                     f"[capture-missing] Exporting {len(to_export)} locally-installed package(s)…",
                     total=len(to_export))
     result = _export_and_submit(to_export, cfg)
-    result.still_missing = max(0, len(not_found_set) - result.submitted)
+    result.still_missing = genuinely_missing
     events.done("capture",
                 f"[capture-missing] Done — {result.submitted} submitted  "
-                f"{result.skipped} skipped  {result.failed} failed",
+                f"{result.skipped} skipped  {result.failed} failed  "
+                f"({len(buckets['inbox'])} inbox not applicable, "
+                f"{genuinely_missing} genuinely missing)",
                 total=len(to_export), submitted=result.submitted,
                 skipped=result.skipped, failed=result.failed,
                 still_missing=result.still_missing)
@@ -198,24 +207,21 @@ def wu_update(force: bool = False) -> CaptureResult:
                     total=0)
         return CaptureResult()
 
-    wu_hwids = _filter_wu_hwids(res_result.not_found, scan_result, cfg)
-    skipped  = len(res_result.not_found) - len(wu_hwids)
+    wu_hwids, skip_reasons = _filter_wu_hwids(res_result.not_found, scan_result, cfg)
+    skip_detail = (f"{skip_reasons['inbox']} inbox (not applicable)  "
+                   f"{skip_reasons['local_driver']} covered by local driver  "
+                   f"{skip_reasons['ignored_class']} ignored class")
 
     if not wu_hwids:
         events.done("windows_update",
-                    "[wu-update] All missing HWIDs have local drivers or are ignored — skipping WU",
-                    total=0, still_missing=len(res_result.not_found))
-        return CaptureResult(still_missing=len(res_result.not_found))
-
-    if skipped:
-        events.start("windows_update",
-                     f"[wu-update] {len(wu_hwids)} HWID(s) need WU  "
-                     f"({skipped} skipped — has local driver or ignored class)",
-                     total=len(wu_hwids), skipped=skipped)
-    else:
-        events.start("windows_update",
-                     f"[wu-update] {len(wu_hwids)} HWID(s) not in repo — triggering Windows Update…",
-                     total=len(wu_hwids))
+                    f"[wu-update] WU skipped — 0 genuinely missing ({skip_detail})",
+                    total=0, still_missing=0, **skip_reasons)
+        return CaptureResult(still_missing=0)
+
+    events.start("windows_update",
+                 f"[wu-update] {len(wu_hwids)} genuinely missing HWID(s) — "
+                 f"triggering Windows Update…  ({skip_detail})",
+                 total=len(wu_hwids), **skip_reasons)
 
     if not _trigger_wu():
         return CaptureResult(still_missing=len(wu_hwids))
@@ -257,41 +263,72 @@ def wu_full() -> CaptureResult:
     return total
 
 
+# ══ Missing-HWID classification ═══════════════════════════════════════════════
+
+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)."""
+    hwid_to_device: dict[str, Device] = {}
+    for dev in scan_result.devices:
+        for h in dev.hwids:
+            hwid_to_device[_norm_hwid(h)] = dev
+
+    buckets: dict[str, list[str]] = {
+        "inbox": [], "oem_local": [], "driverless": [], "unknown": [],
+    }
+    for hwid in not_found:
+        dev = hwid_to_device.get(_norm_hwid(hwid))
+        if dev is None:
+            buckets["unknown"].append(hwid)
+        elif not dev.has_driver:
+            buckets["driverless"].append(hwid)
+        elif dev.is_inbox:
+            buckets["inbox"].append(hwid)
+        else:
+            buckets["oem_local"].append(hwid)
+    return buckets
+
+
 # ══ WU HWID filtering ═════════════════════════════════════════════════════════
 
 def _filter_wu_hwids(
     not_found: list[str],
     scan_result: ScanResult,
     cfg: dict,
-) -> list[str]:
+) -> tuple[list[str], dict[str, int]]:
     """
-    Return only the not_found HWIDs that genuinely need Windows Update:
-      - Device has no driver installed locally (has_driver=False)
-      - Device class is not in wu_ignore_classes config
-      - If HWID is not in scan at all → include (unknown device, safer to try)
+    Return (wu_hwids, skipped_reasons) — only genuinely driverless, non-inbox,
+    non-ignored devices go to Windows Update:
+      - inbox driver bound        → skip (Windows covers it — not applicable)
+      - local OEM driver bound    → skip (capture_missing handles repo upload)
+      - class in wu_ignore_classes → skip
+      - not in scan at all        → include (unknown device — safer to attempt)
     """
     ignore_classes: set[str] = {
         c.lower() for c in cfg.get("wu_ignore_classes", [])
     }
+    buckets = classify_missing(not_found, scan_result)
 
+    result: list[str] = list(buckets["unknown"])
+    skipped = {
+        "inbox": len(buckets["inbox"]),
+        "local_driver": len(buckets["oem_local"]),
+        "ignored_class": 0,
+    }
     hwid_to_device: dict[str, Device] = {}
     for dev in scan_result.devices:
-        for hwid in dev.hwids:
-            hwid_to_device[hwid.upper()] = dev
-
-    result = []
-    for hwid in not_found:
-        dev = hwid_to_device.get(hwid.upper())
-        if dev is None:
+        for h in dev.hwids:
+            hwid_to_device[_norm_hwid(h)] = dev
+    for hwid in buckets["driverless"]:
+        dev = hwid_to_device.get(_norm_hwid(hwid))
+        if dev and ignore_classes and dev.class_name.lower() in ignore_classes:
+            skipped["ignored_class"] += 1
+        else:
             result.append(hwid)
-            continue
-        if dev.has_driver:
-            continue
-        if ignore_classes and dev.class_name.lower() in ignore_classes:
-            continue
-        result.append(hwid)
 
-    return result
+    return result, skipped
 
 
 # ══ Package enumeration ════════════════════════════════════════════════════════
@@ -433,7 +470,7 @@ def _parse_hwid_line(line: str, stripped: str, state: dict) -> None:
         state["in_hwids"]  = False
     elif low.startswith(("hardware ids", "compatible ids")):
         state["in_hwids"] = True
-    elif state["in_hwids"] and "\\" in stripped and not stripped.endswith(":"):
+    elif state["in_hwids"] and _looks_like_hwid(stripped):
         state["hwids"].append(stripped.upper())
     elif ":" in stripped and not line.startswith(" "):
         state["in_hwids"] = False

{driverclient-0.2.2 → driverclient-0.2.4}/src/driverclient/ops/resolve.py

@@ -30,6 +30,8 @@ class ResolveResult:
     trace_id:   str         = ""
     machine_id: str         = ""
     timestamp:  str         = ""
+    total_hwids:     int    = 0
+    already_current: int    = 0
 
     @property
     def has_drivers(self) -> bool:
@@ -89,10 +91,12 @@ def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResul
         trace_id=resp.get("trace_id", ""),
         machine_id=scan_result.machine_id,
         timestamp=datetime.now(timezone.utc).isoformat(),
+        total_hwids=resp.get("total_hwids", len(scan_result.all_hwids)),
+        already_current=resp.get("already_current", 0),
     )
 
-    total_hwids     = resp.get("total_hwids", len(scan_result.all_hwids))
-    already_current = resp.get("already_current", 0)
+    total_hwids     = result.total_hwids
+    already_current = result.already_current
 
     events.done(
         "resolve",

{driverclient-0.2.2 → driverclient-0.2.4}/src/driverclient/ops/scan.py

@@ -33,6 +33,13 @@ class Device:
     has_driver:        bool
     installed_version: str = ""
     class_name:        str = ""   # e.g. "System", "Net", "Display adapters"
+    driver_name:       str = ""   # published INF name, e.g. "oem42.inf" or "machine.inf"
+
+    @property
+    def is_inbox(self) -> bool:
+        """Driver ships with Windows (published name is not oem*.inf) — the repo
+        never needs to cover it, so it's 'not applicable' rather than 'missing'."""
+        return self.has_driver and not self.driver_name.lower().startswith("oem")
 
 
 @dataclass
@@ -66,6 +73,17 @@ class ScanResult:
 _ACPI_VENDEV = re.compile(r"^ACPI\\VEN_([^&]+)&DEV_(.+)$")
 
 
+def _looks_like_hwid(stripped: str) -> bool:
+    """A pnputil ID line: enumerator form (BUS\\...), star compatible ID
+    (*PNP0A0A), bare GUID, or a bare token (WireGuard software devices) —
+    never a 'Key:' header line. IDs never contain whitespace."""
+    if stripped.endswith(":"):
+        return False
+    if "\\" in stripped or stripped.startswith(("*", "{")):
+        return True
+    return len(stripped) >= 3 and not any(c.isspace() for c in stripped)
+
+
 def _canon_hwid(hwid: str) -> str:
     """Fold the two HWID forms Windows reports for one device into one key.
 
@@ -307,7 +325,7 @@ def _apply_hwid_line(line: str, stripped: str, current: dict, in_hwids: bool) ->
     if low.startswith(("hardware ids", "compatible ids")):
         current.setdefault("hwids", [])
         return True
-    if in_hwids and "\\" in stripped and not stripped.endswith(":"):
+    if in_hwids and _looks_like_hwid(stripped):
         current.setdefault("hwids", []).append(stripped.upper())
         return True
     if ":" in stripped and not line.startswith(" "):
@@ -322,6 +340,7 @@ def _flush_device(current: dict, devices: list[Device]) -> None:
             device_name=current.get("name", ""),
             hwids=list(dict.fromkeys(current.get("hwids", []))),
             has_driver=bool(current.get("driver_name")),
+            driver_name=current.get("driver_name", ""),
         ))
 
 
@@ -372,7 +391,17 @@ def _print_summary(r: ScanResult) -> None:
     if r.missing_driver:
         events.progress("scan", "[scan] Missing drivers:")
         for d in r.missing_driver:
-            name  = d.device_name or (d.hwids[0] if d.hwids else d.instance_id)
-            cls   = f"  [{d.class_name}]" if d.class_name else ""
-            events.progress("scan", f"  ✗  {name}{cls}",
+            name = _device_label(d)
+            events.progress("scan", f"  ✗  {name}",
                             device_name=name, class_name=d.class_name)
+
+
+def _device_label(d: Device) -> str:
+    """Human line for a device — 'Unknown [Unknown]' tells the operator nothing,
+    so fall back to instance ID + first HWID."""
+    name = d.device_name
+    if not name or name.lower() == "unknown":
+        first_hwid = d.hwids[0] if d.hwids else ""
+        name = f"{d.instance_id}  {first_hwid}".strip()
+    cls = d.class_name if d.class_name.lower() not in ("", "unknown") else ""
+    return f"{name}  [{cls}]" if cls else name