driverclient 0.2.5__tar.gz → 0.2.6__tar.gz

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

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

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

{driverclient-0.2.5 → driverclient-0.2.6}/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.6/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.6/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.6}/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.5 → driverclient-0.2.6}/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.6}/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.6}/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,
         )