driverclient 0.2.17__tar.gz → 0.2.19__tar.gz

{driverclient-0.2.17 → driverclient-0.2.19}/PKG-INFO

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

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

{driverclient-0.2.17 → driverclient-0.2.19}/src/driverclient/__init__.py

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

{driverclient-0.2.17 → driverclient-0.2.19}/src/driverclient/config.json

@@ -19,8 +19,9 @@
     "usb":    [".inf", ".sys", ".cat", ".dll"]
   },
 
-  "wu_wait_minutes": 10,
+  "wu_wait_minutes": 30,
   "wu_poll_interval_seconds": 30,
+  "wu_quiescent_polls": 2,
   "wu_ignore_classes": ["hidclass", "bluetooth", "printer"],
 
   "automate_wu_fallback": true,

{driverclient-0.2.17 → driverclient-0.2.19}/src/driverclient/ops/capture.py

@@ -714,6 +714,63 @@ def _trigger_wu() -> "_WuTrigger | None":
     return None
 
 
+def _emit_wu_log_line(line: str) -> None:
+    """Turn one raw status line from the WU PowerShell into a friendly GUI event
+    so the operator sees WU's real phase (searching / downloading / installing)
+    live, instead of only a generic 'still working' tick."""
+    up = line.upper()
+    if up.startswith("SERVICE MICROSOFT_UPDATE"):
+        events.ok("windows_update",
+                  "[wu-update] Using the Microsoft Update service (drivers + Microsoft products)")
+    elif up.startswith("SERVICE WINDOWS_UPDATE_FALLBACK"):
+        detail = line.split(None, 2)[2] if len(line.split(None, 2)) > 2 else ""
+        events.warn("windows_update",
+                    f"[wu-update] Microsoft Update unavailable — falling back to default "
+                    f"Windows Update service  {detail}".rstrip())
+    elif up == "SEARCHING":
+        events.progress("windows_update",
+                        "[wu-update] Searching Windows Update for applicable updates… "
+                        "(the first scan can take several minutes)")
+    elif up == "NO_UPDATES":
+        events.progress("windows_update", "[wu-update] Search complete — no applicable updates found")
+    elif up.startswith("DOWNLOADING"):
+        n = line.split()[-1] if line.split() else "?"
+        events.progress("windows_update", f"[wu-update] Downloading {n} update(s)…")
+    elif up == "NONE_DOWNLOADED":
+        events.warn("windows_update", "[wu-update] Nothing downloaded")
+    elif up.startswith("INSTALLING"):
+        n = line.split()[-1] if line.split() else "?"
+        events.progress("windows_update", f"[wu-update] Installing {n} update(s)…")
+    elif up.startswith("INSTALLED"):
+        events.ok("windows_update", f"[wu-update] {line}")
+    elif up.startswith("WU_ERROR"):
+        detail = line[len("WU_ERROR"):].strip()
+        events.warn("windows_update", f"[wu-update] Windows Update error: {detail}", error=detail)
+    else:
+        events.progress("windows_update", f"[wu-update] {line}")
+
+
+def _drain_wu_log(trigger: "_WuTrigger | None", pos: int) -> int:
+    """Emit any new lines the WU PowerShell wrote to its log since offset `pos`,
+    return the new offset. Best-effort — a read failure just leaves `pos`
+    unchanged and never raises into the poll loop. Only the COM path writes a
+    log (trigger.log_path); the usoclient/wuauclt fallbacks have none."""
+    if trigger is None or not trigger.log_path:
+        return pos
+    try:
+        with open(trigger.log_path, "r", encoding="utf-8", errors="replace") as fh:
+            fh.seek(pos)
+            chunk   = fh.read()
+            new_pos = fh.tell()
+    except Exception:
+        return pos
+    for line in chunk.splitlines():
+        line = line.strip()
+        if line:
+            _emit_wu_log_line(line)
+    return new_pos
+
+
 def _poll_and_submit_incremental(wu_start: datetime, cfg: dict,
                                  trigger: "_WuTrigger | None") -> CaptureResult:
     """
@@ -739,12 +796,14 @@ def _poll_and_submit_incremental(wu_start: datetime, cfg: dict,
     seen: set[str] = set()
     total          = CaptureResult()
     empty_polls    = 0
+    log_pos        = 0
 
     events.progress("windows_update",
                     f"[wu-update] Waiting on Windows Update — polling every {poll_secs}s, "
                     f"stops early once WU goes idle (hard cap {wait_min} min)")
 
     while datetime.now(timezone.utc) < deadline:
+        log_pos   = _drain_wu_log(trigger, log_pos)   # surface WU's live phase
         all_new   = _enumerate_packages_since(wu_start, cfg)
         new_batch = [
             p for p in all_new
@@ -789,6 +848,7 @@ def _poll_and_submit_incremental(wu_start: datetime, cfg: dict,
         events.warn("windows_update",
                     f"[wu-update] Reached {wait_min} min hard cap — stopping WU wait")
 
+    _drain_wu_log(trigger, log_pos)   # flush any final lines before cleanup
     if trigger is not None:
         trigger.terminate()
     return total

{driverclient-0.2.17 → driverclient-0.2.19}/src/driverclient/ops/install.py

@@ -68,6 +68,7 @@ class DriverResult:
     error:           str  = ""
     duration_ms:     int  = 0
     reboot_required: bool = False   # installed OK but needs a reboot (pnputil 3010)
+    skipped:         bool = False   # already present in the driver store — not re-fetched/installed
 
 
 @dataclass
@@ -154,9 +155,17 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     # 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.
+    # Live driver-store index: INF name -> highest installed version. Built once,
+    # then UPDATED as each driver installs this pass (see _record_installed) so a
+    # later package of the same driver family (same INF) at an equal-or-older
+    # version is skipped — the driver store already has it. This is skip-if-present
+    # (idempotency), NOT deduplication: no repo package is removed; a newer repo
+    # version still installs over an older store version (store_ver >= repo_ver skips).
+    skip_installed = cfg.get("skip_installed_drivers", True)
+    idx: dict = _installed_inf_index() if skip_installed else {}
+
     drivers = result.drivers
-    if cfg.get("skip_installed_drivers", True):
-        idx = _installed_inf_index()
+    if skip_installed:
         kept = [d for d in drivers if not _already_in_store(d, idx)]
         skipped = len(drivers) - len(kept)
         if skipped:
@@ -179,21 +188,24 @@ def resolve_and_install(force: bool = False) -> InstallResult:
     events.start("install",
                  f"[install] {len(drivers)} driver(s) — starting parallel downloads…",
                  total=len(drivers))
-    all_results = _stream_install(drivers, work_dir, cfg)
+    all_results = _stream_install(drivers, work_dir, cfg, idx, skip_installed)
 
     shutil.rmtree(work_dir, ignore_errors=True)
 
-    installed_ok   = [r for r in all_results if r.success]
+    installed_ok   = [r for r in all_results if r.success and not r.skipped]
+    skipped_now    = [r for r in all_results if r.skipped]
     install_failed = [r for r in all_results if not r.success]
 
-    _confirm(result.trace_id, installed_ok, install_failed, cfg)
+    # Skipped drivers ARE satisfied on the machine — report them upstream as success.
+    _confirm(result.trace_id, installed_ok + skipped_now, install_failed, cfg)
 
     reboot_required = any(r.reboot_required for r in installed_ok)
     reboot_tag = "  — reboot required" if reboot_required else ""
+    skip_tag   = f"  ({len(skipped_now)} already in store)" if skipped_now else ""
     events.done("install",
-                f"[install] Done — {len(installed_ok)} ok  {len(install_failed)} failed{reboot_tag}",
+                f"[install] Done — {len(installed_ok)} ok  {len(install_failed)} failed{skip_tag}{reboot_tag}",
                 total=len(all_results), ok=len(installed_ok), failed=len(install_failed),
-                reboot_required=reboot_required)
+                skipped=len(skipped_now), reboot_required=reboot_required)
     for r in install_failed:
         events.error("install", f"  ✗ {r.binding_id}: {r.error}",
                      binding_id=r.binding_id, error=r.error)
@@ -207,10 +219,16 @@ def resolve_and_install(force: bool = False) -> InstallResult:
 
 # ── Streaming pipeline ──────────────────────────────────────────────────────────
 
-def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverResult]:
+def _stream_install(drivers: list[dict], base: Path, cfg: dict,
+                    idx: dict, skip_installed: bool) -> list[DriverResult]:
     """
     Submit ALL downloads (all levels) simultaneously, then install level-by-level.
     Each driver installs the moment its own download Future completes.
+
+    `idx` is the live driver-store index (INF -> installed version); it is read to
+    skip a driver the store already has and updated after each successful install
+    so same-family duplicates later in the pass are skipped too. Installs run one
+    at a time here (main thread), so mutating `idx` needs no lock.
     """
     repo_url = cfg["local_repo_url"]
     parallel = cfg.get("parallel_downloads", 6)
@@ -225,7 +243,7 @@ def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverRe
                         f"[install] {_level_label(level)} ({len(level_futs[level])} driver(s))…",
                         category=_level_label(level), count=len(level_futs[level]))
         for fut in as_completed(level_futs[level]):
-            all_results.append(_process_completed(fut, future_info, cfg))
+            all_results.append(_process_completed(fut, future_info, cfg, idx, skip_installed))
 
     executor.shutdown(wait=False)
     return all_results
@@ -266,12 +284,23 @@ def _process_completed(
     fut: Future,
     future_info: dict[Future, tuple[int, dict]],
     cfg: dict,
+    idx: dict,
+    skip_installed: bool,
 ) -> DriverResult:
     """Handle one completed download Future: install if ok, return DriverResult."""
     _, driver = future_info[fut]
     bid = driver.get("binding_id", "")
     cat = driver.get("category", "other")
 
+    # A driver installed earlier THIS pass may have added the same INF (another
+    # package of the same driver family), so a package that was missing at
+    # pass-start can now already be in the store at an equal-or-newer version.
+    # Re-check against the live index and skip the redundant re-install.
+    if skip_installed and _already_in_store(driver, idx):
+        events.ok("install", f"  ⭑ [{cat}] {bid}  already in driver store — skipped",
+                  binding_id=bid, category=cat, skipped=True)
+        return DriverResult(binding_id=bid, success=True, skipped=True)
+
     try:
         dest, dl_ok = fut.result()
     except Exception as e:
@@ -283,6 +312,8 @@ def _process_completed(
     t0 = time.monotonic()
     ok, err, reboot = _install_driver(driver, dest, cfg)
     dur = int((time.monotonic() - t0) * 1000)
+    if ok:
+        _record_installed(driver, idx)   # update live index so same-family dupes skip
     tag = " (reboot required)" if reboot else ""
     line = f"  {'✓' if ok else '✗'} [{cat}] {bid}  ({dur}ms){tag}"
     emit = events.ok if ok else events.error
@@ -292,6 +323,20 @@ def _process_completed(
                         duration_ms=dur, reboot_required=reboot)
 
 
+def _record_installed(driver: dict, idx: dict) -> None:
+    """Fold a just-installed driver's INF(s)+version into the live store index, so a
+    later package of the same driver family at an equal-or-older version is skipped
+    this pass — mirrors what `pnputil /enum-drivers` will report on the next scan."""
+    ver = _parse_ver(driver.get("version_label", ""))
+    if not ver:
+        return
+    for f in driver.get("files", []):
+        name = f.get("filename", "").lower()
+        if f.get("file_role") == "inf" or name.endswith(".inf"):
+            if idx.get(name) is None or ver > idx[name]:
+                idx[name] = ver
+
+
 def _download_driver(driver: dict, base: Path, repo_url: str,
                      cfg: dict) -> tuple[Path, bool]:
     """Download all files for one driver. Returns (dest_dir, success)."""