driverclient 0.2.5__tar.gz → 0.2.7__tar.gz

{driverclient-0.2.5 → driverclient-0.2.7}/PKG-INFO

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

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

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/__init__.py

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

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/core/hardware.py

@@ -10,12 +10,12 @@ Strategy:
 """
 import hashlib
 import json
-import subprocess
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 
 from driverclient.config import get
+from driverclient.core import proc
 
 # ── PowerShell profile script ──────────────────────────────────────────────────
 # Runs in ONE subprocess and returns all system data as JSON.
@@ -83,7 +83,7 @@ def get_hwids() -> list[str]:
     cfg   = get()
     hwids = []
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["pnputil", "/enum-devices", "/connected", "/ids"],
             capture_output=True, text=True,
             timeout=cfg["timeout_short"],
@@ -134,7 +134,7 @@ def get_installed_versions(hwids: list[str]) -> dict[str, str]:
 def _run_ps(script: str, timeout: int) -> str:
     """Run a PowerShell script inline. Returns stdout or '' on failure."""
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["powershell", "-NoProfile", "-NonInteractive",
              "-ExecutionPolicy", "Bypass", "-Command", script],
             capture_output=True, text=True, timeout=timeout,
@@ -227,7 +227,7 @@ def _profile_from_wmic() -> dict:
 def _installed_versions_wmic(cfg: dict) -> dict[str, str]:
     versions: dict[str, str] = {}
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["wmic", "path", "Win32_PnPSignedDriver",
              "get", "HardWareID,DriverVersion", "/format:csv"],
             capture_output=True, text=True,
@@ -266,7 +266,7 @@ def _wmic(query: str) -> str:
     """Run a wmic query and return the first non-empty value."""
     cfg = get()
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["wmic"] + query.split() + ["/format:value"],
             capture_output=True, text=True,
             timeout=cfg.get("timeout_tiny", 10),

driverclient-0.2.7/src/driverclient/core/hwid.py

@@ -0,0 +1,135 @@
+"""
+hwid.py — Shared HWID identity mechanism. SINGLE SOURCE OF TRUTH.
+
+⚠️  VENDORED: this file is copied BYTE-IDENTICAL into two repos:
+      - client (client-package): driverclient/core/hwid.py
+      - server (driverserver):   backend/server/core/hwid.py
+    Both copies MUST stay identical. The contract is tests/hwid_vectors.json —
+    both repos run it and must produce the same output. Change here → copy there
+    → run vectors on both. Do NOT edit one copy in isolation.
+
+WHY THIS EXISTS
+    A device's HWIDs come from Windows (pnputil / SetupAPI); a driver package's
+    HWIDs come from the INF text. They describe the same hardware but in
+    slightly different string forms and orders. Matching them reliably (for
+    download/resolve) and indexing them reliably (for upload/capture) requires
+    ONE canonical form and ONE specificity ranking used by BOTH sides. Exact
+    string matching without this is why identical drivers looked "not found".
+
+MODEL (mirrors Windows PnP)
+    A device exposes several HWIDs, from most-specific (hardware IDs) down to
+    generic (compatible IDs). A driver INF declares the HWIDs it supports. The
+    correct driver is the INF that matches the device's MOST-SPECIFIC id.
+    - canonicalize(): fold the two string forms of one id together.
+    - specificity(): higher = more specific (drives ranked matching + tie-break).
+    - is_targetable(): can a driver realistically be authored for this id? Used
+      to DROP generic/class/software ids (PCI\\CC_*, bare PCI\\VEN_*, USB\\CLASS_*,
+      SWD\\, ROOT\\, PRINTENUM\\, *PNP…) so they never count as "missing".
+    - matchable_ids(): a device's canonical, targetable ids, most-specific first
+      — exactly what the client should send and the server should walk.
+"""
+import re
+
+# ── Canonicalization ─────────────────────────────────────────────────────────
+
+_ACPI_VENDEV = re.compile(r"^ACPI\\VEN_([0-9A-Z]+)&DEV_([0-9A-Z]+)")
+
+
+def canonicalize(hwid: str) -> str:
+    """Fold the string forms of one HWID into a single comparable key.
+
+    Rules (order matters):
+      1. strip + uppercase
+      2. drop a single leading '*' (enumerator-independent compatible id marker)
+      3. ACPI: 'ACPI\\VEN_INT&DEV_3394' -> 'ACPI\\INT3394' (pnputil/INF form)
+    PCI/USB/HID keep every component (VEN/DEV/SUBSYS/REV/CC) — specificity(),
+    not canonicalize(), handles tiers, so no structural stripping happens here.
+    """
+    s = hwid.strip().upper()
+    if s.startswith("*"):
+        s = s[1:]
+    m = _ACPI_VENDEV.match(s)
+    if m:
+        tail = s[m.end():]  # preserve any &SUBSYS_/&REV_ tail after the fold
+        s = f"ACPI\\{m.group(1)}{m.group(2)}{tail}"
+    return s
+
+
+# ── Specificity (ranked matching + tie-break) ────────────────────────────────
+
+def specificity(hwid: str) -> int:
+    """Higher = more specific. A device's own id list is roughly ordered, but we
+    compute a score so the server can pick the best INF when several match and
+    so both sides rank identically regardless of source ordering.
+
+    Core device identity (DEV_/PID_/specific ACPI/PNP) is worth 100; SUBSYS adds
+    10; REV adds 1. Pure class/compatible/bare-vendor ids score < 100.
+    """
+    c = canonicalize(hwid)
+    score = 0
+    has_core = bool(
+        "&DEV_" in c                      # PCI device
+        or ("VID_" in c and "PID_" in c)  # USB / HID device
+        or re.search(r"PNP[0-9A-F]{4}", c)       # PNP function id, any form (ACPI\PNP… or bare)
+        or re.match(r"^ACPI\\[0-9A-Z]{3,}\d", c) # folded ACPI vendor+device (e.g. INT3394)
+    )
+    if has_core:
+        score += 100
+    if "SUBSYS_" in c:
+        score += 10
+    if "&REV_" in c:
+        score += 1
+    return score
+
+
+def is_targetable(hwid: str) -> bool:
+    """True if a driver package can realistically be authored to cover this id.
+
+    Drops the ids that inflate 'not_found' and that no INF ever targets:
+    class-code only (PCI\\CC_*), bare vendor (PCI\\VEN_8086), USB\\CLASS_* without
+    PID, and software/bus roots (SWD\\, ROOT\\, PRINTENUM\\, SW\\, STORAGE\\Volume).
+    """
+    c = canonicalize(hwid)
+    enumerator = c.split("\\", 1)[0]
+    if enumerator in _NON_TARGETABLE_ENUMERATORS:
+        return False
+    return specificity(c) >= 100
+
+
+_NON_TARGETABLE_ENUMERATORS = {
+    "SWD", "ROOT", "PRINTENUM", "SW", "STORAGE", "HTREE", "BTH", "DISPLAY",
+}
+
+
+# ── Device id ranking ─────────────────────────────────────────────────────────
+
+def matchable_ids(hwids: list[str]) -> list[str]:
+    """A device's canonical, TARGETABLE HWIDs, most-specific first, deduped.
+
+    This is what the client should send per device and what the server should
+    walk (first hit in the repo index = the driver). Generic/class/software ids
+    are dropped, so a device with a working driver never shows as 'missing'
+    just because it also advertises PCI\\CC_0604.
+    """
+    seen: dict[str, int] = {}
+    for h in hwids:
+        c = canonicalize(h)
+        if is_targetable(c) and c not in seen:
+            seen[c] = specificity(c)
+    return sorted(seen, key=lambda c: seen[c], reverse=True)
+
+
+def canonical_all(hwids: list[str]) -> list[str]:
+    """Canonicalize + dedupe every id (targetable or not), order preserved.
+
+    Used when indexing an INF's declared ids: an INF may legitimately declare a
+    less-specific id, so keep them all — but canonicalized so lookups line up.
+    """
+    out: list[str] = []
+    seen: set[str] = set()
+    for h in hwids:
+        c = canonicalize(h)
+        if c and c not in seen:
+            seen.add(c)
+            out.append(c)
+    return out

driverclient-0.2.7/src/driverclient/core/proc.py

@@ -0,0 +1,41 @@
+"""
+client/core/proc.py — subprocess wrapper that never flashes a console window.
+
+The client shells out to console tools (pnputil, powershell, wmic, usoclient).
+When it runs standalone from a terminal that is harmless. But when it is
+embedded in a windowed host — the System Assistant PyInstaller `--windowed`
+(no-console) exe — every console child is given its own NEW console window by
+Windows, so the operator sees black cmd/PowerShell windows flashing on screen.
+
+CREATE_NO_WINDOW (+ a hidden STARTUPINFO) suppresses that. This mirrors the
+guard the legacy SA driver path already uses (src/windows_update/driver_server.py).
+No-op on non-Windows, where those flags/attrs don't exist.
+
+Route ALL client subprocess calls through proc.run() so the guard can never be
+forgotten at a call site.
+"""
+import subprocess
+import sys
+
+if sys.platform == "win32":
+    _CREATE_NO_WINDOW = 0x08000000
+
+    def _no_window_kwargs() -> dict:
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        startupinfo.wShowWindow = subprocess.SW_HIDE
+        return {"creationflags": _CREATE_NO_WINDOW, "startupinfo": startupinfo}
+else:
+    def _no_window_kwargs() -> dict:
+        return {}
+
+
+def run(cmd, **kwargs) -> subprocess.CompletedProcess:
+    """subprocess.run() that never shows a console window on Windows.
+
+    Injects CREATE_NO_WINDOW + hidden STARTUPINFO unless the caller already
+    supplied those kwargs. All other behavior is identical to subprocess.run.
+    """
+    for key, value in _no_window_kwargs().items():
+        kwargs.setdefault(key, value)
+    return subprocess.run(cmd, **kwargs)

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/main.py

@@ -26,6 +26,7 @@ from driverclient.ops.capture import (
     wu_full,
     wu_update,
 )
+from driverclient.ops.diagnose import run_diagnostics
 from driverclient.ops.install import resolve_and_install
 from driverclient.ops.resolve import resolve
 from driverclient.ops.scan import scan
@@ -40,6 +41,7 @@ _OPERATIONS: dict[str, callable] = {
     "wu-update":           wu_update,
     "wu-full":             wu_full,
     "automate":            run_automation,
+    "test":                run_diagnostics,
 }
 
 

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/ops/capture.py

@@ -37,6 +37,7 @@ import functools
 
 from driverclient import events
 from driverclient.config import get
+from driverclient.core import hwid as hwid_mod, proc
 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
@@ -349,13 +350,13 @@ def classify_missing(not_found: list[str], scan_result: ScanResult) -> dict[str,
     hwid_to_device: dict[str, Device] = {}
     for dev in scan_result.devices:
         for h in dev.hwids:
-            hwid_to_device[_norm_hwid(h)] = dev
+            hwid_to_device[hwid_mod.canonicalize(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))
+        dev = hwid_to_device.get(hwid_mod.canonicalize(hwid))
         if dev is None:
             buckets["unknown"].append(hwid)
         elif not dev.has_driver:
@@ -396,9 +397,9 @@ def _filter_wu_hwids(
     hwid_to_device: dict[str, Device] = {}
     for dev in scan_result.devices:
         for h in dev.hwids:
-            hwid_to_device[_norm_hwid(h)] = dev
+            hwid_to_device[hwid_mod.canonicalize(h)] = dev
     for hwid in buckets["driverless"]:
-        dev = hwid_to_device.get(_norm_hwid(hwid))
+        dev = hwid_to_device.get(hwid_mod.canonicalize(hwid))
         if dev and ignore_classes and dev.class_name.lower() in ignore_classes:
             skipped["ignored_class"] += 1
         else:
@@ -411,7 +412,7 @@ def _filter_wu_hwids(
 
 def _enumerate_all_packages(cfg: dict) -> list[dict]:
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["pnputil", "/enum-drivers"],
             capture_output=True, text=True,
             timeout=cfg.get("timeout_short", 30),
@@ -458,20 +459,6 @@ def _enumerate_packages_since(cutoff: datetime, cfg: dict) -> list[dict]:
     return result
 
 
-def _norm_hwid(hwid: str) -> str:
-    """Normalize an HWID for comparison: uppercase and strip the &REV_* tail.
-
-    The repo's `not_found` list carries the stripped HWID variants
-    (e.g. PCI\\VEN_8086&DEV_9D15&SUBSYS_222C17AA) while the IDs reported by the
-    live machine — both `installed_versions` keys and pnputil /enum-devices —
-    carry a &REV_xx suffix. Comparing the two forms verbatim never matches, so
-    both sides are normalized to the same REV-less, uppercase form.
-    """
-    up  = hwid.upper()
-    idx = up.find("&REV_")
-    return up[:idx] if idx != -1 else up
-
-
 def _published_names_for_hwids(
     delta_hwids: set[str],
     scan_result: ScanResult,
@@ -486,12 +473,12 @@ def _published_names_for_hwids(
     B). Only OEM packages are eligible: inbox (Windows-shipped) drivers are not
     redistributable and the repo never needs them.
     """
-    targets = {_norm_hwid(h) for h in delta_hwids}
+    targets = {hwid_mod.canonicalize(h) for h in delta_hwids}
     names: set[str] = set()
     for dev in scan_result.devices:
         if not dev.has_driver or dev.is_inbox or not dev.driver_name:
             continue
-        if any(_norm_hwid(h) in targets for h in dev.hwids):
+        if any(hwid_mod.canonicalize(h) in targets for h in dev.hwids):
             names.add(dev.driver_name)
     return names
 
@@ -552,7 +539,7 @@ def _wu_reboot_pending() -> bool:
 def _trigger_wu() -> bool:
     for cmd in (["usoclient", "StartScan"], ["wuauclt", "/detectnow"]):
         try:
-            subprocess.run(cmd, capture_output=True, timeout=30)
+            proc.run(cmd, capture_output=True, timeout=30)
             events.ok("windows_update", "[wu-update] Windows Update scan triggered")
             return True
         except Exception:
@@ -705,7 +692,7 @@ def _do_export(pkg: dict, cfg: dict) -> dict | None:
         dest.mkdir()
 
         try:
-            r = subprocess.run(
+            r = proc.run(
                 ["pnputil", "/export-driver", published, str(dest)],
                 capture_output=True, text=True, timeout=timeout,
             )

driverclient-0.2.7/src/driverclient/ops/diagnose.py

@@ -0,0 +1,158 @@
+"""
+client/ops/diagnose.py — the `test` command. READ-ONLY.
+
+Shows, side by side and per device:
+  • what the machine detects  (scan: devices, HWIDs, driver_name, versions)
+  • what the repo serves back  (resolve: to_install / already_current /
+                                not_found / stale)
+  • what capture-delta WOULD harvest, and how that compares to capture-all.
+
+No install, no upload, no Windows Update — nothing changes. Use it to verify
+the identity/matching end to end and to see exactly why capture-delta uploads
+fewer packages than capture-all.
+
+Public API:
+    run_diagnostics() -> dict
+"""
+from driverclient import events
+from driverclient.config import get
+from driverclient.core import hwid as hwid_mod
+from driverclient.ops.capture import _enumerate_all_packages, _find_installed_packages_for_hwids
+from driverclient.ops.resolve import resolve
+from driverclient.ops.scan import scan
+
+
+def _short(name: str, n: int = 44) -> str:
+    name = name or ""
+    return name if len(name) <= n else name[: n - 1] + "…"
+
+
+def _verdict_for(dev, matched: dict, nf_set: set, stale_set: set):
+    """Classify one device against the repo response."""
+    mids = hwid_mod.matchable_ids(dev.hwids)
+    for mid in mids:
+        if mid in matched:
+            return "INSTALL", matched[mid], mid
+    for mid in mids:
+        if mid in stale_set:
+            return "STALE", "", mid
+    for mid in mids:
+        if mid in nf_set:
+            return "NOT_IN_REPO", "", mid
+    if dev.has_driver:
+        return "CURRENT/COVERED", "", (mids[0] if mids else "")
+    return "NO_DRIVER/SW", "", (mids[0] if mids else "")
+
+
+def run_diagnostics() -> dict:
+    cfg = get()
+    events.start("test", "=" * 64)
+    events.start("test", "  TEST — scan vs repo (READ-ONLY: no install / upload / WU)")
+    events.start("test", "=" * 64)
+
+    scan_result = scan(force=True)
+    resolve_result = resolve(force=False)  # consumes the fresh scan just done
+
+    drivers = resolve_result.drivers
+    not_found = list(resolve_result.not_found)
+    stale = list(getattr(resolve_result, "stale", []) or [])
+
+    matched: dict[str, str] = {}
+    for d in drivers:
+        h = d.get("hwid")
+        if h:
+            matched[hwid_mod.canonicalize(h)] = d.get("package_id", "?")
+    nf_set = {hwid_mod.canonicalize(h) for h in not_found}
+    stale_set = {hwid_mod.canonicalize(h) for h in stale}
+
+    # ── SCAN side ────────────────────────────────────────────────────────
+    events.progress("test", "")
+    events.progress(
+        "test",
+        f"── SCAN (system detected) ── {scan_result.vendor} {scan_result.model} | "
+        f"OS {scan_result.os_build} | machine {scan_result.machine_id}",
+    )
+    events.progress(
+        "test",
+        f"   {len(scan_result.devices)} devices | {len(scan_result.has_driver)} with driver | "
+        f"{len(scan_result.missing_driver)} without | "
+        f"{len(scan_result.installed_versions)} installed-version entries",
+    )
+
+    # ── RESOLVE side ─────────────────────────────────────────────────────
+    events.progress("test", "")
+    events.progress("test", f"── RESOLVE (repo {cfg.get('local_repo_url')}) ──")
+    events.progress(
+        "test",
+        f"   to_install={len(drivers)}  already_current={resolve_result.already_current}  "
+        f"not_found={len(not_found)}  stale={len(stale)}",
+    )
+
+    # ── Per-device cross reference ───────────────────────────────────────
+    order = ["INSTALL", "STALE", "NOT_IN_REPO", "CURRENT/COVERED", "NO_DRIVER/SW"]
+    buckets: dict[str, list[str]] = {k: [] for k in order}
+    for dev in scan_result.devices:
+        v, pkg, mid = _verdict_for(dev, matched, nf_set, stale_set)
+        drv = "inbox" if dev.is_inbox else (dev.driver_name or "no-drv")
+        ver = f" v{dev.installed_version}" if dev.installed_version else ""
+        line = f"{_short(dev.device_name)}  [{dev.class_name or '-'}]  {drv}{ver}"
+        if v == "INSTALL":
+            line += f"  → repo pkg {pkg}"
+        elif mid:
+            line += f"  ({mid})"
+        buckets[v].append(line)
+
+    events.progress("test", "")
+    events.progress("test", "── PER-DEVICE (scan ⟷ repo) ──")
+    for v in order:
+        events.progress("test", f"  [{v}] {len(buckets[v])}")
+        for line in buckets[v]:
+            events.progress("test", f"      {line}")
+
+    # ── Harvest preview vs capture-all ───────────────────────────────────
+    delta = set(not_found) | set(stale)
+    to_harvest = _find_installed_packages_for_hwids(delta, scan_result, cfg)
+    all_pkgs = _enumerate_all_packages(cfg)
+
+    events.progress("test", "")
+    events.progress(
+        "test",
+        f"── HARVEST PREVIEW — capture-delta WOULD upload {len(to_harvest)} OEM package(s) ──",
+    )
+    for p in to_harvest:
+        events.progress(
+            "test",
+            f"      {p.get('published_name')}  "
+            f"({p.get('provider_name', '?')} {p.get('class_name', '')})",
+        )
+    events.progress("test", "")
+    events.progress(
+        "test",
+        f"── capture-all WOULD dump {len(all_pkgs)} DriverStore package(s) "
+        f"(everything, incl. inbox / co-installers) ──",
+    )
+    events.progress(
+        "test",
+        f"   Why the gap: capture-delta uploads ONLY OEM drivers backing the repo "
+        f"delta (not_found ∪ stale) = {len(to_harvest)}; capture-all dumps all "
+        f"{len(all_pkgs)} regardless. Devices marked CURRENT/COVERED or inbox are "
+        f"intentionally NOT harvested by delta.",
+    )
+    events.done("test", "=" * 64)
+
+    return {
+        "scan": {
+            "devices": len(scan_result.devices),
+            "with_driver": len(scan_result.has_driver),
+            "installed_versions": len(scan_result.installed_versions),
+        },
+        "resolve": {
+            "to_install": len(drivers),
+            "already_current": resolve_result.already_current,
+            "not_found": len(not_found),
+            "stale": len(stale),
+        },
+        "verdicts": {k: len(v) for k, v in buckets.items()},
+        "harvest_delta_packages": len(to_harvest),
+        "capture_all_packages": len(all_pkgs),
+    }

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/ops/install.py

@@ -24,6 +24,7 @@ from pathlib import Path
 
 from driverclient import events
 from driverclient.config import get
+from driverclient.core import proc
 from driverclient.core.http import http_download_retry, http_post_retry
 from driverclient.ops.resolve import ResolveResult, resolve
 
@@ -286,7 +287,7 @@ def _install_driver(driver: dict, driver_dir: Path, cfg: dict) -> tuple[bool, st
             inf_files = list(driver_dir.glob("*.inf"))
             if not inf_files:
                 return False, "No INF file found", False
-            r = subprocess.run(
+            r = proc.run(
                 ["pnputil", "/add-driver", str(inf_files[0]), "/install", "/subdirs"],
                 capture_output=True, text=True,
                 timeout=cfg["timeout_long"],
@@ -298,7 +299,7 @@ def _install_driver(driver: dict, driver_dir: Path, cfg: dict) -> tuple[bool, st
             if not exe_files:
                 return False, "No EXE file found", False
             flags = driver.get("install_flags", "/S")
-            r = subprocess.run(
+            r = proc.run(
                 [str(exe_files[0])] + flags.split(),
                 capture_output=True,
                 timeout=cfg["timeout_install"],
@@ -309,7 +310,7 @@ def _install_driver(driver: dict, driver_dir: Path, cfg: dict) -> tuple[bool, st
             inf_files = list(driver_dir.glob("*.inf"))
             if not inf_files:
                 return False, "No firmware INF", False
-            r = subprocess.run(
+            r = proc.run(
                 ["pnputil", "/add-driver", str(inf_files[0]), "/install"],
                 capture_output=True, text=True,
                 timeout=cfg["timeout_long"],

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/ops/resolve.py

@@ -19,6 +19,7 @@ from pathlib import Path
 
 from driverclient import events
 from driverclient.config import get
+from driverclient.core import hwid as hwid_mod
 from driverclient.core.http import http_post_retry
 from driverclient.ops.scan import ScanResult, scan
 
@@ -75,6 +76,22 @@ def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResul
     repo_url   = cfg["local_repo_url"]
     session_id = str(uuid.uuid4())
 
+    # Per-device ranked, targetable id lists (shared hwid module). The server
+    # matches per device (ranked walk) and a matched device consumes its whole
+    # group, so generic/class ids never inflate not_found.
+    hwid_groups = [
+        ids for ids in (hwid_mod.matchable_ids(d.hwids) for d in scan_result.devices) if ids
+    ]
+    # Version map ALSO keyed by the canonical ids the server matches on, so its
+    # already-current / stale check lands (raw keys kept for back-compat).
+    canon_versions = {
+        hwid_mod.canonicalize(k): v for k, v in scan_result.installed_versions.items()
+    }
+    for d in scan_result.devices:
+        if d.installed_version:
+            for mid in hwid_mod.matchable_ids(d.hwids):
+                canon_versions.setdefault(mid, d.installed_version)
+
     payload = {
         "machine_id":         scan_result.machine_id,
         "session_id":         session_id,
@@ -84,7 +101,8 @@ def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResul
         "arch":               scan_result.arch,
         "firmware_version":   scan_result.firmware_version,
         "hwids":              scan_result.all_hwids,
-        "installed_versions": scan_result.installed_versions,
+        "hwid_groups":        hwid_groups,
+        "installed_versions": {**scan_result.installed_versions, **canon_versions},
         "force":              force or cfg.get("force_resolve", False),
     }
 

{driverclient-0.2.5 → driverclient-0.2.7}/src/driverclient/ops/scan.py

@@ -9,8 +9,6 @@ Public API:
     scan(force=False) -> ScanResult
 """
 import json
-import re
-import subprocess
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timedelta, timezone
@@ -18,6 +16,7 @@ from pathlib import Path
 
 from driverclient import events
 from driverclient.config import get
+from driverclient.core import hwid as hwid_mod, proc
 from driverclient.core.hardware import (
     compute_fingerprint,
     get_installed_versions,
@@ -70,9 +69,6 @@ class ScanResult:
         return [d for d in self.devices if d.has_driver]
 
 
-_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) —
@@ -84,25 +80,6 @@ def _looks_like_hwid(stripped: str) -> bool:
     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.
-
-    `installed_versions` comes from Win32_PnPSignedDriver.HardWareID — the
-    canonical VEN_/DEV_ form with a &REV_xx tail, and ACPI IDs written as
-    ACPI\\VEN_INT&DEV_3394.  The HWIDs sent to /resolve come from pnputil
-    /enum-devices — raw form, no &REV, ACPI as ACPI\\INT3394.  Both collapse to
-    one comparable key: uppercase, &REV_* dropped, ACPI VEN_/DEV_ concatenated.
-    """
-    up  = hwid.upper()
-    idx = up.find("&REV_")
-    if idx != -1:
-        up = up[:idx]
-    m = _ACPI_VENDEV.match(up)
-    if m:
-        up = f"ACPI\\{m.group(1)}{m.group(2)}"
-    return up
-
-
 def _installed_prefix_index(installed_versions: dict[str, str]) -> dict[str, str]:
     """Expand each canonical installed HWID into its &-boundary prefixes.
 
@@ -115,7 +92,7 @@ def _installed_prefix_index(installed_versions: dict[str, str]) -> dict[str, str
     """
     idx: dict[str, str] = {}
     for key, ver in installed_versions.items():
-        canon = _canon_hwid(key)
+        canon = hwid_mod.canonicalize(key)
         parts = canon.split("&")
         acc   = parts[0]
         prefixes = [acc]
@@ -167,7 +144,7 @@ def scan(force: bool = False) -> ScanResult:
         prefix_idx = _installed_prefix_index(installed_versions)
         for h in all_hwids:
             if h not in installed_versions:
-                ver = prefix_idx.get(_canon_hwid(h))
+                ver = prefix_idx.get(hwid_mod.canonicalize(h))
                 if ver:
                     installed_versions[h] = ver
 
@@ -261,7 +238,7 @@ def _enumerate_devices(cfg: dict) -> list[Device]:
 def _run_pnputil_ids(timeout: int) -> str | None:
     """pnputil /enum-devices /connected /ids  — HWIDs + driver_name."""
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["pnputil", "/enum-devices", "/connected", "/ids"],
             capture_output=True, text=True, timeout=timeout,
         )
@@ -278,7 +255,7 @@ def _run_pnputil_ids(timeout: int) -> str | None:
 def _run_pnputil_classes(timeout: int) -> str | None:
     """pnputil /enum-devices /connected  — class_name per device."""
     try:
-        r = subprocess.run(
+        r = proc.run(
             ["pnputil", "/enum-devices", "/connected"],
             capture_output=True, text=True, timeout=timeout,
         )