driverclient 0.2.20__tar.gz → 0.2.21__tar.gz

{driverclient-0.2.20 → driverclient-0.2.21}/PKG-INFO

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

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

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/__init__.py

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

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/config.json

@@ -1,13 +1,20 @@
 {
+  "_comment_mode": "mode = 'live' (default): SA/first-boot install+reboot+WU+capture. mode = 'offline': WinPE download-only to offline_driver_dir, then win11.bat.j2 DISM-injects. See examples/config.json for the full prod-deploy note.",
+  "mode": "live",
   "local_repo_url": "http://localhost:8000",
   "node_key": "REPLACE_WITH_YOUR_NODE_KEY",
 
   "default_command": "automate",
 
+  "_comment_compression": "zstd downloads decompressed on-the-fly; keep true, set false only if zstd fails in WinPE.",
+  "compression": true,
   "parallel_downloads": 6,
   "parallel_uploads": 8,
   "parallel_exports": 4,
 
+  "_comment_offline_driver_dir": "offline mode writes files here (WinPE); DISM injects into the applied image W:\\. Ignored in live mode.",
+  "offline_driver_dir": "W:\\drivers",
+
   "driver_root": "C:\\DriverServer",
   "cache_dir":   "C:\\DriverServer\\client",
   "work_dir":    "C:\\DriverServer\\client\\staging",

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/config.py

@@ -13,6 +13,26 @@ DEFAULTS: dict = {
     "local_repo_url":    "http://localhost:8000",
     "node_key":          "",
 
+    # ── Mode ──────────────────────────────────────────────────────────────
+    # "live"    = SA / first-boot: batched pnputil install + reboot loop + WU +
+    #             capture (today's behaviour; handles the post-boot device tail).
+    # "offline" = pre-boot / WinPE: scan → resolve → DOWNLOAD ONLY to
+    #             offline_driver_dir. No install, no reboot, no WU, no capture —
+    #             win11.bat.j2's DISM step injects the files into the image.
+    "mode": "live",
+
+    # ── Offline (pre-boot / WinPE) ────────────────────────────────────────
+    # Where offline mode writes the decompressed driver files. DISM
+    # (win11.bat.j2) injects them into the applied image at W:\ afterward — the
+    # client only downloads; it never runs DISM itself.
+    "offline_driver_dir": "W:\\drivers",
+
+    # Request zstd-compressed downloads (decompressed on-the-fly in core/http.py):
+    # GPU ≈ 450 MB instead of 1.3 GB. True everywhere by default; set False only
+    # as a WinPE fallback if zstd ever fails to load there. Gates the
+    # Accept-Encoding: zstd request header sent by http_download.
+    "compression": True,
+
     # ── Command ───────────────────────────────────────────────────────────
     "default_command":   "automate",
 

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/core/http.py

@@ -194,7 +194,12 @@ def http_download(url: str, dest: Path, sha256_expected: str,
     """
     cfg = get()
     t = timeout or cfg["timeout_long"]
-    headers = {**_headers(), "Accept-Encoding": "zstd"}
+    # Only advertise zstd when compression is enabled. Offline/WinPE keeps it on
+    # (GPU ≈ 450 MB vs 1.3 GB); set compression=false as a fallback if zstd ever
+    # fails to load in WinPE, and the server serves the file uncompressed.
+    headers = dict(_headers())
+    if cfg.get("compression", True):
+        headers["Accept-Encoding"] = "zstd"
 
     req = urllib.request.Request(url, headers=headers)
     dest.parent.mkdir(parents=True, exist_ok=True)

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/main.py

@@ -28,6 +28,7 @@ from driverclient.ops.capture import (
 )
 from driverclient.ops.diagnose import run_diagnostics
 from driverclient.ops.install import resolve_and_install
+from driverclient.ops.offline import resolve_and_download
 from driverclient.ops.resolve import resolve
 from driverclient.ops.scan import scan
 
@@ -35,6 +36,7 @@ _OPERATIONS: dict[str, callable] = {
     "scan":                scan,
     "resolve":             resolve,
     "resolve-and-install": resolve_and_install,
+    "offline":             resolve_and_download,
     "capture-all":         capture_all,
     "capture-missing":     capture_missing,
     "capture-delta":       capture_delta,

driverclient-0.2.21/src/driverclient/ops/download.py

@@ -0,0 +1,63 @@
+"""
+client/ops/download.py — Shared driver-file download primitives.
+
+Both the LIVE install path (ops/install.py) and the OFFLINE / pre-boot path
+(ops/offline.py) fetch the same package files from the repo:
+
+    GET {repo_url}/files/{package_id}/{filename}   (streamed, zstd on-the-fly,
+                                                     sha256-verified — see core/http.py)
+
+Factored out here so the two modes share one download implementation:
+  • download_driver()  — fetch every file for ONE driver into base/<binding_id>/
+  • download_drivers() — fan the above out across a driver list in parallel
+"""
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from driverclient.core.http import http_download_retry
+
+
+def download_driver(driver: dict, base: Path, repo_url: str,
+                    cfg: dict) -> tuple[Path, bool]:
+    """Download all files for one driver into base/<binding_id>/.
+    Returns (dest_dir, success). success is False if ANY file failed."""
+    bid    = driver.get("binding_id") or driver.get("package_id", "")
+    pkg_id = driver["package_id"]
+    dest   = base / bid
+    dest.mkdir(parents=True, exist_ok=True)
+
+    ok = True
+    for f in driver.get("files", []):
+        url  = f"{repo_url}/files/{pkg_id}/{f['filename']}"
+        path = dest / f["filename"]
+        if not http_download_retry(url, path, f["sha256"],
+                                   timeout=cfg["timeout_long"]):
+            ok = False
+
+    return dest, ok
+
+
+def download_drivers(drivers: list[dict], base: Path,
+                     cfg: dict) -> list[tuple[dict, Path | None, bool]]:
+    """Download a list of drivers into `base` in parallel.
+
+    Returns a list of (driver, dest_dir | None, success) in completion order.
+    A driver that raised during download yields (driver, None, False) rather
+    than propagating — the caller decides how to report failures.
+    """
+    repo_url = cfg["local_repo_url"]
+    parallel = cfg.get("parallel_downloads", 6)
+
+    results: list[tuple[dict, Path | None, bool]] = []
+    with ThreadPoolExecutor(max_workers=parallel) as executor:
+        fut_map = {executor.submit(download_driver, d, base, repo_url, cfg): d
+                   for d in drivers}
+        for fut in as_completed(fut_map):
+            driver = fut_map[fut]
+            try:
+                dest, ok = fut.result()
+            except Exception:
+                results.append((driver, None, False))
+                continue
+            results.append((driver, dest, ok))
+    return results

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/ops/install.py

@@ -26,7 +26,8 @@ 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.core.http import http_post_retry
+from driverclient.ops.download import download_driver
 from driverclient.ops.resolve import ResolveResult, resolve
 
 # Install order: lower number first (hardware dependency)
@@ -248,7 +249,7 @@ def _stream_install(drivers: list[dict], base: Path, cfg: dict) -> list[DriverRe
     results:    list[DriverResult]      = []
     downloaded: list[tuple[dict, Path]] = []
     with ThreadPoolExecutor(max_workers=parallel) as executor:
-        fut_map = {executor.submit(_download_driver, d, base, repo_url, cfg): d
+        fut_map = {executor.submit(download_driver, d, base, repo_url, cfg): d
                    for d in ordered}
         for fut in as_completed(fut_map):
             driver = fut_map[fut]
@@ -364,23 +365,8 @@ def _install_one_exe(driver: dict, driver_dir: Path, cfg: dict) -> DriverResult:
                         duration_ms=dur, reboot_required=reboot)
 
 
-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)."""
-    bid    = driver.get("binding_id") or driver.get("package_id", "")
-    pkg_id = driver["package_id"]
-    dest   = base / bid
-    dest.mkdir(parents=True, exist_ok=True)
-
-    ok = True
-    for f in driver.get("files", []):
-        url  = f"{repo_url}/files/{pkg_id}/{f['filename']}"
-        path = dest / f["filename"]
-        if not http_download_retry(url, path, f["sha256"],
-                                   timeout=cfg["timeout_long"]):
-            ok = False
-
-    return dest, ok
+# Driver-file download lives in ops/download.py (download_driver), shared with
+# the offline / pre-boot path.
 
 
 # ── Driver installation ─────────────────────────────────────────────────────────

driverclient-0.2.21/src/driverclient/ops/offline.py

@@ -0,0 +1,101 @@
+"""
+client/ops/offline.py — Offline / pre-boot (WinPE) driver staging.
+
+The FAST path, matching the old system: run inside WinPE against a freshly
+applied Windows image, enumerate the machine's real HWIDs, resolve them against
+the driverserver, and DOWNLOAD the matched driver files to offline_driver_dir
+(default W:\\drivers). That's ALL this op does — it never installs.
+
+win11.bat.j2 runs the injection afterward:
+
+    X:\\tools\\driverclient\\driverclient.exe          (this op, mode=offline)
+    dism /image:W:\\ /add-driver /driver:W:\\drivers /recurse /forceunsigned
+
+So there is NO live install, NO reboot loop, NO Windows Update, NO capture here —
+everything is injected offline into the image and is present instantly at first
+boot. The small post-boot device tail that WinPE can't see is handled later by
+the LIVE mode (SA finalization).
+
+Layout: each driver's files land in offline_driver_dir/<binding_id>/, so
+duplicate INF filenames across packages never collide and DISM /recurse picks
+them all up.
+
+Public API:
+    resolve_and_download() -> OfflineResult
+"""
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from driverclient import events
+from driverclient.config import get
+from driverclient.ops.download import download_drivers
+from driverclient.ops.resolve import resolve
+
+
+@dataclass
+class OfflineResult:
+    downloaded_ok:   list[str] = field(default_factory=list)
+    download_failed: list[str] = field(default_factory=list)
+    not_found:       list[str] = field(default_factory=list)
+    trace_id:        str       = ""
+    target_dir:      str       = ""
+
+    @property
+    def ok_count(self)   -> int: return len(self.downloaded_ok)
+    @property
+    def fail_count(self) -> int: return len(self.download_failed)
+
+
+def resolve_and_download() -> OfflineResult:
+    """
+    Scan → resolve (empty installed_versions → full matched set) → download every
+    matched driver's files to offline_driver_dir. No install. Returns OfflineResult.
+    """
+    cfg    = get()
+    target = Path(cfg.get("offline_driver_dir", "W:\\drivers"))
+
+    # force=True: fresh WinPE session, no meaningful cache to reuse — always scan
+    # the real hardware. offline=True: send empty installed_versions.
+    result = resolve(force=True, offline=True)
+
+    if not result.has_drivers:
+        events.done("offline",
+                    "[offline] Nothing to download — no matched drivers",
+                    total=0, not_found=len(result.not_found))
+        return OfflineResult(trace_id=result.trace_id,
+                             not_found=result.not_found,
+                             target_dir=str(target))
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    drivers = result.drivers
+    events.start("offline",
+                 f"[offline] {len(drivers)} driver(s) → downloading to {target} …",
+                 total=len(drivers))
+
+    downloaded = download_drivers(drivers, target, cfg)
+
+    ok:     list[str] = []
+    failed: list[str] = []
+    for driver, _dest, success in downloaded:
+        bid = driver.get("binding_id") or driver.get("package_id", "")
+        (ok if success else failed).append(bid)
+
+    for bid in failed:
+        events.error("offline", f"  ✗ {bid}: download_failed", binding_id=bid)
+
+    events.done(
+        "offline",
+        f"[offline] Done — {len(ok)} downloaded  {len(failed)} failed  "
+        f"→ {target}  (DISM injects offline next)",
+        total=len(downloaded), ok=len(ok), failed=len(failed),
+        target_dir=str(target),
+    )
+
+    return OfflineResult(
+        downloaded_ok=ok,
+        download_failed=failed,
+        not_found=result.not_found,
+        trace_id=result.trace_id,
+        target_dir=str(target),
+    )

{driverclient-0.2.20 → driverclient-0.2.21}/src/driverclient/ops/resolve.py

@@ -54,11 +54,17 @@ class ResolveResult:
         return bool(self.not_found or self.stale)
 
 
-def resolve(force: bool = False) -> ResolveResult:
+def resolve(force: bool = False, offline: bool = False) -> ResolveResult:
     """
     Load (or run) a hardware scan, then POST to /resolve.
     Returns ResolveResult with drivers[] and not_found[].
     Saves result to ds_resolve.json.
+
+    offline: pre-boot / WinPE mode. The scan runs against WinPE, not the applied
+    image, so any "installed" versions it sees are irrelevant to the target. Send
+    installed_versions empty (and no inbox hints) so the server offers the FULL
+    matched set — every physically-present device's driver, GPU included — to be
+    DISM-injected into the fresh image. See ops/offline.py.
     """
     cfg = get()
 
@@ -69,10 +75,11 @@ def resolve(force: bool = False) -> ResolveResult:
             return cached
 
     scan_result: ScanResult = scan(force=force)
-    return _query_repo(scan_result, cfg, force)
+    return _query_repo(scan_result, cfg, force, offline)
 
 
-def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResult:
+def _query_repo(scan_result: ScanResult, cfg: dict, force: bool,
+                offline: bool = False) -> ResolveResult:
     repo_url   = cfg["local_repo_url"]
     session_id = str(uuid.uuid4())
 
@@ -112,8 +119,11 @@ def _query_repo(scan_result: ScanResult, cfg: dict, force: bool) -> ResolveResul
         "firmware_version":   scan_result.firmware_version,
         "hwids":              scan_result.all_hwids,
         "hwid_groups":        hwid_groups,
-        "inbox_hwids":        inbox_ids,
-        "installed_versions": {**scan_result.installed_versions, **canon_versions},
+        # Offline: no inbox hints and empty installed_versions → server offers the
+        # full matched set for the fresh image (nothing counts as already-current).
+        "inbox_hwids":        [] if offline else inbox_ids,
+        "installed_versions": {} if offline
+                              else {**scan_result.installed_versions, **canon_versions},
         "force":              force or cfg.get("force_resolve", False),
     }