driverclient 0.2.26__tar.gz → 0.2.28__tar.gz

{driverclient-0.2.26 → driverclient-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.26
+Version: 0.2.28
 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.28/pyproject.toml

@@ -0,0 +1,123 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "driverclient"
+version = "0.2.28"
+description = "Driver Server client with an embeddable connector for config injection at runtime."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Raja Sanaullah", email = "sanaullah@99technologies.com" },
+]
+keywords = ["driver", "windows", "pnputil", "deployment", "pxe"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Operating System :: Microsoft :: Windows",
+    "Intended Audience :: System Administrators",
+]
+dependencies = [
+    "zstandard>=0.22.0",
+]
+
+[project.urls]
+Homepage = "https://example.com/driverclient"
+
+# ── Dependency groups (PEP 735) ───────────────────────────────────────────────
+# Tooling only — never shipped in the wheel (dependency groups are not part of
+# the built distribution). ruff is pinned to the same version as the repo-root
+# .pre-commit-config.yaml so a local commit and a manual run apply identical rules.
+[dependency-groups]
+dev = [
+    "ruff==0.15.22",
+    "mypy",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/driverclient"]
+# Ship non-Python package data (config template + type marker) inside the wheel.
+artifacts = [
+    "src/driverclient/config.json",
+    "src/driverclient/py.typed",
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/driverclient",
+    "README.md",
+    "pyproject.toml",
+]
+
+# ── Ruff (lint + format) ──────────────────────────────────────────────────────
+# Mirrors backend/pyproject.toml so both halves of the repo read the same, with
+# two deliberate differences: target-version follows this package's
+# requires-python (>=3.10, not the backend's 3.12), and the ASYNC/FastAPI rules
+# are dropped — the client is synchronous (threads + concurrent.futures).
+[tool.ruff]
+target-version = "py310"          # floor of requires-python; the client runs on stock Windows Pythons
+line-length = 100
+extend-exclude = [".venv", ".venv-smoke", "dist", "build"]
+
+[tool.ruff.lint]
+select = [
+    "E", "W",   # pycodestyle
+    "F",        # pyflakes (unused imports/names)
+    "I",        # isort (sorts imports on --fix)
+    "N",        # pep8-naming
+    "B",        # flake8-bugbear (common bug patterns)
+    "UP",       # pyupgrade (modernize syntax)
+    "SIM",      # flake8-simplify
+    "C4",       # flake8-comprehensions
+    "RUF",      # ruff-specific
+    "LOG",      # flake8-logging — logging hygiene
+]
+ignore = [
+    "E501",   # line length is enforced by the formatter, not the linter
+    "RUF002", # ambiguous unicode (×, –) in docstrings — intentional typography
+    "RUF003", # ambiguous unicode (×, –) in comments — intentional typography
+    # ── Parked: promote to enforced after a dedicated cleanup pass ──
+    "N818",   # exception *Error suffix — renaming exception classes is cross-cutting churn
+    "UP042",  # str-Enum -> StrEnum — behavior-sensitive under JSON serialization
+    "UP046",  # PEP 695 generic class
+    "UP047",  # PEP 695 generic function
+]
+
+[tool.ruff.lint.per-file-ignores]
+"src/driverclient/__init__.py" = ["F401"]  # re-exports are intentional in the package entry point
+"examples/run_client.py" = ["E402"]        # stdout/stderr must be reconfigured before the driverclient import
+
+[tool.ruff.lint.isort]
+known-first-party = ["driverclient"]
+combine-as-imports = true
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+# ── Mypy (non-strict baseline; ratchet strictness per-module later) ───────────
+# The package ships py.typed, so these annotations are part of its public
+# contract for embedding apps — worth tightening (disallow_untyped_defs) once
+# the current signatures are annotated.
+[tool.mypy]
+python_version = "3.10"
+# src layout: the import root is src/, not the package directory. mypy_path lets
+# `import driverclient` resolve from examples/ and the root scripts without an
+# editable install. (mypy accepts only ONE of packages/modules/files — so the
+# package is listed here as a path, not via `packages`.)
+mypy_path = "src"
+files = ["src/driverclient", "examples", "smoke_test.py", "bump_version.py"]
+# Analyse as Windows. Without this, mypy assumes the host platform, treats every
+# `if sys.platform == "win32":` block as unreachable, and silently skips the bulk
+# of the client's real logic — and `import winreg` fails to resolve on macOS/Linux.
+platform = "win32"
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_unused_configs = true
+
+[[tool.mypy.overrides]]
+# Third-party packages without type stubs.
+module = ["zstandard.*"]
+ignore_missing_imports = true

{driverclient-0.2.26 → driverclient-0.2.28}/src/driverclient/__init__.py

@@ -19,13 +19,14 @@ Typical use from an embedding app (e.g. a PyQt front-end):
 Config merge priority (highest wins):
     DEFAULTS  <  DS_CLIENT_CONFIG env file  <  config_path file  <  kwargs
 """
+
 from driverclient import config as _config
 from driverclient.events import ClientEvent, using_sink
 from driverclient.main import run as _run
 
-__all__ = ["DriverClient", "ClientEvent"]
+__all__ = ["ClientEvent", "DriverClient"]
 
-__version__ = "0.2.26"
+__version__ = "0.2.28"
 
 
 class DriverClient:

{driverclient-0.2.26 → driverclient-0.2.28}/src/driverclient/__main__.py

@@ -1,4 +1,5 @@
 """Allow: python -m driverclient"""
+
 from driverclient.main import run
 
 run()

{driverclient-0.2.26 → driverclient-0.2.28}/src/driverclient/config.py

@@ -4,15 +4,15 @@ driverclient/config.py — Load client settings.
 Merge priority (highest wins):
   DEFAULTS  <  DS_CLIENT_CONFIG env file  <  file passed to load()  <  overrides
 """
+
 import json
 import os
 from pathlib import Path
 
 DEFAULTS: dict = {
     # ── Server ────────────────────────────────────────────────────────────
-    "local_repo_url":    "http://localhost:8000",
-    "node_key":          "",
-
+    "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).
@@ -20,36 +20,29 @@ DEFAULTS: dict = {
     #             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",
-
+    "default_command": "automate",
     # ── Parallelism ───────────────────────────────────────────────────────
     "parallel_downloads": 6,
-    "parallel_uploads":   8,
-    "parallel_exports":   4,
-
+    "parallel_uploads": 8,
+    "parallel_exports": 4,
     # ── Paths ─────────────────────────────────────────────────────────────
     "driver_root": "C:\\DriverServer",
-    "cache_dir":   "C:\\DriverServer\\client",
-    "work_dir":    "C:\\DriverServer\\client\\staging",
-
+    "cache_dir": "C:\\DriverServer\\client",
+    "work_dir": "C:\\DriverServer\\client\\staging",
     # ── Cache TTL ─────────────────────────────────────────────────────────
     # ds_scan.json / ds_resolve.json are reused if younger than this many minutes
     "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
@@ -60,60 +53,54 @@ DEFAULTS: dict = {
     # 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
-    "dump_extensions":   [".inf", ".sys", ".cat"],
-
+    "dump_extensions": [".inf", ".sys", ".cat"],
     # Per-category extension overrides — key = class_name from pnputil (lowercase)
     # Categories not listed here use dump_extensions above
     "dump_extensions_overrides": {
-        "system":  [".inf", ".sys", ".cat", ".dll"],
-        "usb":     [".inf", ".sys", ".cat", ".dll"]
+        "system": [".inf", ".sys", ".cat", ".dll"],
+        "usb": [".inf", ".sys", ".cat", ".dll"],
     },
-
     # ── Windows Update ────────────────────────────────────────────────────
     # ABSOLUTE ceiling for the WU wait — a safety backstop, NOT the expected
     # wait. The loop stops as soon as WU actually goes idle (see below); this
     # only bounds a stuck/hanging WU so SA can never stall.
-    "wu_wait_minutes":          30,
+    "wu_wait_minutes": 30,
     "wu_poll_interval_seconds": 30,
     # Empty polls required AFTER Windows Update has gone idle before we stop.
     # While WU is still working (install process alive), empty polls are NOT
     # counted — so a scan/download that takes 2 min or 8 min both get exactly
     # the time they need. This is what makes the wait adaptive instead of a
     # fixed timer.
-    "wu_quiescent_polls":       2,
+    "wu_quiescent_polls": 2,
     # Classes to skip when deciding which not-found HWIDs trigger WU.
     # Empty list = no filtering (default — make no assumptions).
     # Use lowercase class names as reported by pnputil, e.g. "hidclass", "bluetooth".
-    "wu_ignore_classes":        ["hidclass"],
-
+    "wu_ignore_classes": ["hidclass"],
     # ── Automate flags ────────────────────────────────────────────────────
     "automate_wu_fallback": True,
-    "automate_re_resolve":  False,
+    "automate_re_resolve": False,
     # Extra same-boot scan→resolve→install passes after the first install, to
     # pick up devices exposed only once a parent driver binds (chained deps).
     # 0 disables the loop (single install pass). Stops early when a pass finds
     # no new repo drivers or installs nothing.
     "automate_rescan_passes": 3,
-    "force_resolve":        False,
+    "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,
-    "timeout_short":     30,
-    "timeout_medium":    60,
-    "timeout_long":      120,
-    "timeout_install":   600,
-    "timeout_wmi_slow":  90,
-
+    "timeout_tiny": 10,
+    "timeout_short": 30,
+    "timeout_medium": 60,
+    "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

{driverclient-0.2.26 → driverclient-0.2.28}/src/driverclient/core/hardware.py

@@ -8,6 +8,7 @@ Strategy:
              Still works on Win10/11; deprecated in Win11 22H2+ but warnings
              go to stderr which is captured and discarded.
 """
+
 import hashlib
 import json
 import uuid
@@ -60,32 +61,34 @@ Get-CimInstance -ClassName Win32_PnPSignedDriver |
 
 # ── Public API ─────────────────────────────────────────────────────────────────
 
+
 def compute_fingerprint() -> str:
     """Stable machine UUID derived from MB serial + CPU ID + first NIC MAC."""
     data = _get_profile_data()
     if data:
-        mb  = data.get("serial_board", "") or data.get("serial_bios", "")
+        mb = data.get("serial_board", "") or data.get("serial_bios", "")
         cpu = data.get("cpu_id", "")
         mac = data.get("mac", "")
     else:
         with ThreadPoolExecutor(max_workers=3) as ex:
-            mb_f  = ex.submit(_wmic, "baseboard get SerialNumber")
+            mb_f = ex.submit(_wmic, "baseboard get SerialNumber")
             cpu_f = ex.submit(_wmic, "cpu get ProcessorId")
             mac_f = ex.submit(_wmic, "nic where AdapterTypeId=0 get MACAddress")
             mb, cpu, mac = mb_f.result(), cpu_f.result(), mac_f.result()
-    raw    = f"{mb}|{cpu}|{mac}"
+    raw = f"{mb}|{cpu}|{mac}"
     digest = hashlib.sha256(raw.encode()).digest()
     return str(uuid.UUID(bytes=digest[:16]))
 
 
 def get_hwids() -> list[str]:
     """Return all connected device HWIDs via pnputil."""
-    cfg   = get()
+    cfg = get()
     hwids = []
     try:
         r = proc.run(
             ["pnputil", "/enum-devices", "/connected", "/ids"],
-            capture_output=True, text=True,
+            capture_output=True,
+            text=True,
             timeout=cfg["timeout_short"],
         )
         for line in r.stdout.splitlines():
@@ -114,9 +117,9 @@ def get_installed_versions(hwids: list[str]) -> dict[str, str]:
     Tries PowerShell first, falls back to wmic CSV.
     Caches result keyed by sorted HWID list hash.
     """
-    cfg       = get()
+    cfg = get()
     hwid_hash = hashlib.sha256("|".join(sorted(hwids)).encode()).hexdigest()[:16]
-    cache     = _load_versions_cache(cfg, hwid_hash)
+    cache = _load_versions_cache(cfg, hwid_hash)
     if cache is not None:
         return cache
 
@@ -131,13 +134,23 @@ def get_installed_versions(hwids: list[str]) -> dict[str, str]:
 
 # ── PowerShell helpers ─────────────────────────────────────────────────────────
 
+
 def _run_ps(script: str, timeout: int) -> str:
     """Run a PowerShell script inline. Returns stdout or '' on failure."""
     try:
         r = proc.run(
-            ["powershell", "-NoProfile", "-NonInteractive",
-             "-ExecutionPolicy", "Bypass", "-Command", script],
-            capture_output=True, text=True, timeout=timeout,
+            [
+                "powershell",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                script,
+            ],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
         )
         return r.stdout.strip() if r.returncode == 0 else ""
     except Exception:
@@ -146,8 +159,8 @@ def _run_ps(script: str, timeout: int) -> str:
 
 def _get_profile_data() -> dict:
     """Run _PROFILE_PS and return parsed JSON dict, or {} on failure."""
-    cfg  = get()
-    out  = _run_ps(_PROFILE_PS, cfg.get("timeout_wmi_slow", 90))
+    cfg = get()
+    out = _run_ps(_PROFILE_PS, cfg.get("timeout_wmi_slow", 90))
     if not out:
         return {}
     try:
@@ -163,7 +176,11 @@ def _profile_from_ps(data: dict) -> dict:
     # human name in ComputerSystemProduct.Version / SystemFamily (e.g. "ThinkPad T460s").
     # Prefer the first meaningful candidate that isn't just the machine-type code.
     friendly = ""
-    for cand in (data.get("product_version"), data.get("system_family"), data.get("friendly_model")):
+    for cand in (
+        data.get("product_version"),
+        data.get("system_family"),
+        data.get("friendly_model"),
+    ):
         cand = _clean(cand or "")
         if _is_meaningful(cand) and cand.lower() != model.lower():
             friendly = cand
@@ -171,21 +188,21 @@ def _profile_from_ps(data: dict) -> dict:
     if not friendly:
         friendly = _clean(data.get("friendly_model", "") or "")
     return {
-        "vendor":           _clean(data.get("vendor", "Unknown")),
-        "model":            model,
-        "friendly_model":   _clean(friendly),
-        "serial":           _clean(data.get("serial_bios") or data.get("serial_board", "")),
-        "chassis_type":     _parse_chassis(data.get("chassis", "")),
-        "os_build":         _safe_int(data.get("os_build", "0")),
-        "arch":             "x64",
+        "vendor": _clean(data.get("vendor", "Unknown")),
+        "model": model,
+        "friendly_model": _clean(friendly),
+        "serial": _clean(data.get("serial_bios") or data.get("serial_board", "")),
+        "chassis_type": _parse_chassis(data.get("chassis", "")),
+        "os_build": _safe_int(data.get("os_build", "0")),
+        "arch": "x64",
         "firmware_version": _clean(data.get("firmware", "")),
     }
 
 
 def _installed_versions_ps() -> dict[str, str]:
     """Get installed driver versions via PowerShell. Returns {} on failure."""
-    cfg  = get()
-    out  = _run_ps(_INSTALLED_PS, cfg.get("timeout_wmi_slow", 90))
+    cfg = get()
+    out = _run_ps(_INSTALLED_PS, cfg.get("timeout_wmi_slow", 90))
     if not out:
         return {}
     try:
@@ -203,23 +220,24 @@ def _installed_versions_ps() -> dict[str, str]:
 
 # ── wmic fallback helpers ──────────────────────────────────────────────────────
 
+
 def _profile_from_wmic() -> dict:
     with ThreadPoolExecutor(max_workers=6) as ex:
-        vendor_f   = ex.submit(_wmic, "computersystem get Manufacturer")
-        model_f    = ex.submit(_wmic, "computersystem get Model")
+        vendor_f = ex.submit(_wmic, "computersystem get Manufacturer")
+        model_f = ex.submit(_wmic, "computersystem get Model")
         friendly_f = ex.submit(_get_friendly_model_wmic)
-        serial_f   = ex.submit(_get_serial_wmic)
-        chassis_f  = ex.submit(_get_chassis_wmic)
-        os_f       = ex.submit(_wmic, "os get BuildNumber")
-        fw_f       = ex.submit(_wmic, "bios get SMBIOSBIOSVersion")
+        serial_f = ex.submit(_get_serial_wmic)
+        chassis_f = ex.submit(_get_chassis_wmic)
+        os_f = ex.submit(_wmic, "os get BuildNumber")
+        fw_f = ex.submit(_wmic, "bios get SMBIOSBIOSVersion")
     return {
-        "vendor":           vendor_f.result() or "Unknown",
-        "model":            model_f.result()  or "Unknown",
-        "friendly_model":   friendly_f.result(),
-        "serial":           serial_f.result(),
-        "chassis_type":     chassis_f.result(),
-        "os_build":         _safe_int(os_f.result()),
-        "arch":             "x64",
+        "vendor": vendor_f.result() or "Unknown",
+        "model": model_f.result() or "Unknown",
+        "friendly_model": friendly_f.result(),
+        "serial": serial_f.result(),
+        "chassis_type": chassis_f.result(),
+        "os_build": _safe_int(os_f.result()),
+        "arch": "x64",
         "firmware_version": fw_f.result() or "",
     }
 
@@ -228,16 +246,23 @@ def _installed_versions_wmic(cfg: dict) -> dict[str, str]:
     versions: dict[str, str] = {}
     try:
         r = proc.run(
-            ["wmic", "path", "Win32_PnPSignedDriver",
-             "get", "HardWareID,DriverVersion", "/format:csv"],
-            capture_output=True, text=True,
+            [
+                "wmic",
+                "path",
+                "Win32_PnPSignedDriver",
+                "get",
+                "HardWareID,DriverVersion",
+                "/format:csv",
+            ],
+            capture_output=True,
+            text=True,
             timeout=cfg.get("timeout_wmi_slow", 90),
         )
         for line in r.stdout.splitlines()[1:]:
             parts = line.strip().split(",")
             if len(parts) >= 3:
                 hwid = parts[1].strip().upper()
-                ver  = parts[2].strip()
+                ver = parts[2].strip()
                 if hwid and ver:
                     versions[hwid] = ver
     except Exception as e:
@@ -267,8 +292,9 @@ def _wmic(query: str) -> str:
     cfg = get()
     try:
         r = proc.run(
-            ["wmic"] + query.split() + ["/format:value"],
-            capture_output=True, text=True,
+            ["wmic", *query.split(), "/format:value"],
+            capture_output=True,
+            text=True,
             timeout=cfg.get("timeout_tiny", 10),
         )
         for line in r.stdout.splitlines():
@@ -283,7 +309,7 @@ def _wmic(query: str) -> str:
 
 # ── Chassis parsing ────────────────────────────────────────────────────────────
 
-_LAPTOP_CHASSIS  = {8, 9, 10, 11, 12, 14, 30, 31, 32}
+_LAPTOP_CHASSIS = {8, 9, 10, 11, 12, 14, 30, 31, 32}
 _DESKTOP_CHASSIS = {3, 4, 5, 6, 7, 13, 15, 16, 35, 36}
 
 
@@ -292,7 +318,7 @@ def _parse_chassis(raw: str) -> str:
     try:
         cleaned = raw.replace("{", "").replace("}", "").replace(" ", "")
         nums = {int(x) for x in cleaned.split(",") if x.strip().isdigit()}
-        if any(n in _LAPTOP_CHASSIS  for n in nums):
+        if any(n in _LAPTOP_CHASSIS for n in nums):
             return "laptop"
         if any(n in _DESKTOP_CHASSIS for n in nums):
             return "desktop"
@@ -303,8 +329,16 @@ def _parse_chassis(raw: str) -> str:
 
 # ── Shared utilities ───────────────────────────────────────────────────────────
 
-_JUNK_VALUES = {"", "none", "unknown", "to be filled by o.e.m.",
-                "not specified", "name", "default string", "system product name"}
+_JUNK_VALUES = {
+    "",
+    "none",
+    "unknown",
+    "to be filled by o.e.m.",
+    "not specified",
+    "name",
+    "default string",
+    "system product name",
+}
 
 
 def _is_meaningful(val: str) -> bool: