driverclient 0.2.11__tar.gz → 0.2.13__tar.gz

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

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

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

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

@@ -31,6 +31,16 @@ DEFAULTS: dict = {
     "cache_ttl_minutes": 15,
 
     # ── Capture ───────────────────────────────────────────────────────────
+    # Skip packages larger than this (MB) during capture — keeps the repo light.
+    # A complete driver = its full size; a few (Intel graphics ~1 GB) are huge and
+    # bloat upload/scan/forward. Windows inbox display covers the machine until
+    # graphics is installed later (WU/vendor), like OS imaging never bundles it.
+    # Everything smaller (network/storage/chipset/audio/camera/…) is captured.
+    # 0 = capture EVERYTHING including graphics (the outbox forward is a separate
+    # non-blocking loop that retries transient failures, so big packages don't
+    # block or get lost). Set >0 only if you want a lighter repo.
+    "capture_max_package_mb": 0,
+
     # [".inf", ".sys", ".cat"] — minimum for server to redistribute and install
     # [".inf", ".sys", ".cat", ".dll"] — adds co-installer DLLs
     # ["*"] — all files in the driver package directory
@@ -60,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,
@@ -68,6 +84,13 @@ DEFAULTS: dict = {
     "timeout_long":      120,
     "timeout_install":   600,
     "timeout_wmi_slow":  90,
+
+    # Package-upload timeout scales with archive size instead of a flat 60s so a
+    # ~1 GB graphics package never times out mid-transfer. This is the assumed
+    # worst-case sustained upload throughput (MB/s) used to derive the socket
+    # timeout ceiling: timeout ≈ compressed_MB / this + timeout_short. Lower = more
+    # slack (safer against timeouts), higher = tighter. Floor is timeout_medium.
+    "upload_min_throughput_mbps": 2,
 }
 
 _config: dict | None = None

{driverclient-0.2.11 → driverclient-0.2.13}/src/driverclient/core/http.py

@@ -117,7 +117,19 @@ def http_upload_package(
     Retries up to max_retries times with exponential backoff.
     """
     cfg = get()
-    t = timeout or cfg["timeout_medium"]
+
+    # Scale the socket timeout by archive size. A fixed timeout_medium (60s) times
+    # out mid-transfer on big packages (Intel graphics ~1 GB compressed), which the
+    # retry loop then re-sends from scratch — churn, or an outright drop. urllib's
+    # timeout is per-socket-op (not a total deadline), so a generous value is only a
+    # ceiling on a single stall, never a cap on the whole upload. Treat the caller/
+    # config timeout as a floor and give large archives proportionally more time,
+    # assuming a conservative sustained throughput.
+    floor = timeout or cfg["timeout_medium"]
+    size_mb = len(archive_bytes) / (1024 * 1024)
+    min_mbps = float(cfg.get("upload_min_throughput_mbps", 2) or 2)
+    scaled = int(size_mb / max(min_mbps, 0.1)) + int(cfg.get("timeout_short", 30))
+    t = max(floor, scaled)
 
     boundary = uuid.uuid4().hex
     meta_bytes = json.dumps({**metadata, "archive_encoding": content_encoding}).encode()

{driverclient-0.2.11 → driverclient-0.2.13}/src/driverclient/ops/capture.py

@@ -709,6 +709,24 @@ def _do_export(pkg: dict, cfg: dict) -> dict | None:
                         published_name=published, error=r.stderr[:120])
             return None
 
+        # Skip giant packages (default: none). A complete driver = its full size,
+        # and a few drivers (notably Intel graphics ~1 GB) are huge. Those bloat
+        # the repo and slow upload/scan/forward; Windows' inbox display driver
+        # covers the machine until graphics is installed later (WU/vendor), the
+        # same way OS imaging never bundles graphics. Everything else — network,
+        # storage, chipset, audio, camera, etc. — is small and stays in the repo.
+        # Set capture_max_package_mb=0 to capture everything (incl. graphics).
+        max_mb = int(cfg.get("capture_max_package_mb", 0) or 0)
+        if max_mb > 0:
+            total = sum(f.stat().st_size for f in dest.rglob("*") if f.is_file())
+            if total > max_mb * 1024 * 1024:
+                events.warn("dump",
+                            f"  [skip] {published} is {total / 1e6:.0f} MB > cap "
+                            f"{max_mb} MB — skipping (install via WU/vendor)",
+                            published_name=published, size_mb=int(total / 1e6),
+                            cap_mb=max_mb)
+                return None
+
         try:
             # Pack EVERY file pnputil /export-driver produced — the driver's INF
             # references them all (verified even for large packages), so this is

{driverclient-0.2.11 → 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)