driverclient 0.2.6__tar.gz → 0.2.7__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "driverclient"
-version = "0.2.6"
+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.6 → 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.6"
+__version__ = "0.2.7"
 
 
 class DriverClient:

{driverclient-0.2.6 → 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.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),
+    }