driverclient 0.2.12__tar.gz → 0.2.13__tar.gz

{driverclient-0.2.12 → driverclient-0.2.13}/PKG-INFO

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

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

{driverclient-0.2.12 → driverclient-0.2.13}/src/driverclient/__init__.py

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

{driverclient-0.2.12 → driverclient-0.2.13}/src/driverclient/config.py

@@ -70,6 +70,12 @@ DEFAULTS: dict = {
     # no new repo drivers or installs nothing.
     "automate_rescan_passes": 3,
     "force_resolve":        False,
+    # The server now offers every driver matching each device (primary + extensions
+    # + companions). Before downloading each, skip it if its INF is already in the
+    # Windows driver store at the same-or-newer version — so a still-current big
+    # driver (e.g. graphics) is never re-downloaded, while missing/extension drivers
+    # still install. Set False to force-reinstall everything the server offers.
+    "skip_installed_drivers": True,
 
     # ── HTTP timeouts (seconds) ───────────────────────────────────────────
     "timeout_tiny":      10,

{driverclient-0.2.12 → driverclient-0.2.13}/src/driverclient/ops/install.py

@@ -13,6 +13,7 @@ Download pipeline:
 Public API:
     resolve_and_install(force=False) -> InstallResult
 """
+import re
 import shutil
 import subprocess
 import time
@@ -86,6 +87,54 @@ class InstallResult:
         return any(r.reboot_required for r in self.installed_ok)
 
 
+def _parse_ver(s: str) -> tuple | None:
+    """Extract an x.x.x.x version tuple from a string (e.g. a pnputil 'Driver
+    Version: 12/02/2021 1.0.3.0' line or a repo version_label). None if absent."""
+    m = re.search(r"(\d+)\.(\d+)\.(\d+)\.(\d+)", s or "")
+    return tuple(int(x) for x in m.groups()) if m else None
+
+
+def _installed_inf_index() -> dict:
+    """Map original INF name (lowercase) → highest installed driver-version tuple,
+    parsed from `pnputil /enum-drivers`. Lets us skip re-downloading/installing a
+    driver the machine already has at the same-or-newer version. Best-effort: on any
+    error/parse miss it returns {} so nothing is ever wrongly skipped."""
+    idx: dict = {}
+    try:
+        r = proc.run(["pnputil", "/enum-drivers"], capture_output=True, text=True, timeout=120)
+        if r.returncode != 0:
+            return {}
+        cur = None
+        for line in r.stdout.splitlines():
+            low = line.lower()
+            if "original name" in low and ":" in line:
+                cur = line.split(":", 1)[1].strip().lower()
+            elif "driver version" in low and cur:
+                v = _parse_ver(line)
+                if v and (cur not in idx or v > idx[cur]):
+                    idx[cur] = v
+                cur = None
+    except Exception:
+        return {}
+    return idx
+
+
+def _already_in_store(driver: dict, idx: dict) -> bool:
+    """True when every INF this driver ships is already in the driver store at a
+    same-or-newer version — so it needn't be downloaded/installed again. Conservative:
+    returns False (→ install) whenever the version or an INF can't be confirmed."""
+    if not idx:
+        return False
+    ver = _parse_ver(driver.get("version_label", ""))
+    if not ver:
+        return False
+    infs = [f["filename"].lower() for f in driver.get("files", [])
+            if f.get("file_role") == "inf" or f.get("filename", "").lower().endswith(".inf")]
+    if not infs:
+        return False
+    return all(idx.get(name) is not None and idx[name] >= ver for name in infs)
+
+
 def resolve_and_install(force: bool = False) -> InstallResult:
     """
     Run resolve (or load cache) then download + install all available drivers.
@@ -99,14 +148,38 @@ def resolve_and_install(force: bool = False) -> InstallResult:
                     total=0)
         return InstallResult(trace_id=result.trace_id)
 
+    # Server now offers EVERY driver matching each device (primary + extensions +
+    # companions), so nothing is dropped by an assumption. Freshness is decided HERE
+    # against the real driver store: skip any package whose INF(s) are already present
+    # at the same-or-newer version — so a still-current big driver (graphics) is not
+    # re-downloaded, while missing/extension drivers still install. Toggle off with
+    # skip_installed_drivers=false to force-reinstall everything.
+    drivers = result.drivers
+    if cfg.get("skip_installed_drivers", True):
+        idx = _installed_inf_index()
+        kept = [d for d in drivers if not _already_in_store(d, idx)]
+        skipped = len(drivers) - len(kept)
+        if skipped:
+            events.progress(
+                "install",
+                f"[install] {skipped} driver(s) already current in the driver store — skipping",
+                skipped=skipped,
+            )
+        drivers = kept
+        if not drivers:
+            events.done("install",
+                        "[install] Nothing to install — all resolved drivers already current",
+                        total=0)
+            return InstallResult(trace_id=result.trace_id)
+
     session_id = str(uuid.uuid4())
     work_dir   = Path(cfg.get("work_dir", "C:\\DriverServer\\client\\staging")) / session_id
     work_dir.mkdir(parents=True, exist_ok=True)
 
     events.start("install",
-                 f"[install] {len(result.drivers)} driver(s) — starting parallel downloads…",
-                 total=len(result.drivers))
-    all_results = _stream_install(result.drivers, work_dir, cfg)
+                 f"[install] {len(drivers)} driver(s) — starting parallel downloads…",
+                 total=len(drivers))
+    all_results = _stream_install(drivers, work_dir, cfg)
 
     shutil.rmtree(work_dir, ignore_errors=True)