driverclient 0.2.0__py3-none-any.whl

driverclient/__init__.py

@@ -0,0 +1,73 @@
+"""
+driverclient — Driver Server client, packaged for embedding.
+
+Typical use from an embedding app (e.g. a PyQt front-end):
+
+    from driverclient import DriverClient
+
+    # args only
+    client = DriverClient(local_repo_url="http://REPO_HOST:8000", node_key="...")
+
+    # file only
+    client = DriverClient(config_path="/etc/driverclient.json")
+
+    # file as base, individual keys overridden by kwargs
+    client = DriverClient(config_path="/etc/driverclient.json", node_key="...")
+
+    result = client.run("capture-all")   # or client.run() for default_command
+
+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"]
+
+__version__ = "0.2.0"
+
+
+class DriverClient:
+    """
+    Configures the process-global client config, then runs operations.
+
+    A single active client per process is supported: constructing a
+    DriverClient resets and reloads the shared global config singleton.
+    Construct one instance and reuse it; constructing another replaces
+    the active configuration.
+    """
+
+    def __init__(self, config_path: str | None = None, **kwargs) -> None:
+        """
+        Args:
+            config_path: optional path to a JSON config file used as the base.
+                         If omitted, the DS_CLIENT_CONFIG env file or the
+                         packaged config.json is used (existing behavior).
+            **kwargs:    individual config keys that override everything else,
+                         including values from config_path.
+        """
+        _config.reset()
+        self.config = _config.load(path=config_path, overrides=kwargs)
+
+    def run(self, command: str | None = None, on_event=None) -> object:
+        """
+        Run a client operation and return its result object.
+
+        Args:
+            command:  one of the client operations (e.g. "scan", "capture-all",
+                      "automate"). If None, falls back to DS_CLIENT_COMMAND then
+                      the default_command from config.
+            on_event: optional callback ``Callable[[ClientEvent], None]`` invoked
+                      synchronously, in real time, for every progress event the
+                      operation emits. Installed only for the duration of this
+                      run (see events.using_sink) and restored afterwards. When
+                      omitted, events fall back to print + logging so the
+                      terminal experience is unchanged.
+
+        Returns:
+            The operation's result object (ScanResult, InstallResult, ...).
+        """
+        self.on_event = on_event
+        with using_sink(on_event):
+            return _run(command)

driverclient/__main__.py

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

driverclient/config.json

@@ -0,0 +1,36 @@
+{
+  "local_repo_url": "http://localhost:8000",
+  "node_key": "REPLACE_WITH_YOUR_NODE_KEY",
+
+  "default_command": "automate",
+
+  "parallel_downloads": 6,
+  "parallel_uploads": 8,
+  "parallel_exports": 4,
+
+  "driver_root": "C:\\DriverServer",
+  "cache_dir":   "C:\\DriverServer\\client",
+  "work_dir":    "C:\\DriverServer\\client\\staging",
+  "cache_ttl_minutes": 15,
+
+  "dump_extensions": [".inf", ".sys", ".cat"],
+  "dump_extensions_overrides": {
+    "system": [".inf", ".sys", ".cat", ".dll"],
+    "usb":    [".inf", ".sys", ".cat", ".dll"]
+  },
+
+  "wu_wait_minutes": 10,
+  "wu_poll_interval_seconds": 30,
+  "wu_ignore_classes": ["hidclass", "bluetooth", "printer"],
+
+  "automate_wu_fallback": true,
+  "automate_re_resolve": false,
+  "force_resolve": false,
+
+  "timeout_tiny":      10,
+  "timeout_short":     30,
+  "timeout_medium":    60,
+  "timeout_long":      120,
+  "timeout_install":   600,
+  "timeout_wmi_slow":  90
+}

driverclient/config.py

@@ -0,0 +1,98 @@
+"""
+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":          "",
+
+    # ── Command ───────────────────────────────────────────────────────────
+    "default_command":   "automate",
+
+    # ── Parallelism ───────────────────────────────────────────────────────
+    "parallel_downloads": 6,
+    "parallel_uploads":   8,
+    "parallel_exports":   4,
+
+    # ── Paths ─────────────────────────────────────────────────────────────
+    "driver_root": "C:\\DriverServer",
+    "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 ───────────────────────────────────────────────────────────
+    # [".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"],
+
+    # 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"]
+    },
+
+    # ── Windows Update ────────────────────────────────────────────────────
+    "wu_wait_minutes":          10,
+    "wu_poll_interval_seconds": 30,
+    # 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"],
+
+    # ── Automate flags ────────────────────────────────────────────────────
+    "automate_wu_fallback": True,
+    "automate_re_resolve":  False,
+    "force_resolve":        False,
+
+    # ── HTTP timeouts (seconds) ───────────────────────────────────────────
+    "timeout_tiny":      10,
+    "timeout_short":     30,
+    "timeout_medium":    60,
+    "timeout_long":      120,
+    "timeout_install":   600,
+    "timeout_wmi_slow":  90,
+}
+
+_config: dict | None = None
+
+
+def load(path: str | None = None, overrides: dict | None = None) -> dict:
+    global _config
+    if _config is not None:
+        return _config
+
+    if path:
+        config_path = Path(path)
+    elif "DS_CLIENT_CONFIG" in os.environ:
+        config_path = Path(os.environ["DS_CLIENT_CONFIG"])
+    else:
+        config_path = Path(__file__).parent / "config.json"
+
+    data: dict = {}
+    if config_path.exists():
+        with open(config_path) as fh:
+            data = json.load(fh)
+
+    _config = {**DEFAULTS, **data, **(overrides or {})}
+    return _config
+
+
+def get() -> dict:
+    return load()
+
+
+def reset() -> None:
+    global _config
+    _config = None

driverclient/core/hardware.py

@@ -0,0 +1,345 @@
+"""
+client/core/hardware.py — Hardware enumeration for Windows target machines.
+
+Strategy:
+  Primary  — one PowerShell Get-CimInstance call returning JSON.
+             Works on Windows 10 and Windows 11 with no deprecation warnings.
+  Fallback — individual wmic queries (parallel).
+             Still works on Win10/11; deprecated in Win11 22H2+ but warnings
+             go to stderr which is captured and discarded.
+"""
+import hashlib
+import json
+import subprocess
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from driverclient.config import get
+
+# ── PowerShell profile script ──────────────────────────────────────────────────
+# Runs in ONE subprocess and returns all system data as JSON.
+_PROFILE_PS = """\
+try {
+  $cs   = Get-CimInstance -ClassName Win32_ComputerSystem      -ErrorAction Stop
+  $bios = Get-CimInstance -ClassName Win32_BIOS                -ErrorAction Stop
+  $board= Get-CimInstance -ClassName Win32_BaseBoard           -ErrorAction Stop
+  $cpu  = Get-CimInstance -ClassName Win32_Processor           -ErrorAction Stop |
+            Select-Object -First 1
+  $nic  = Get-CimInstance -ClassName Win32_NetworkAdapter      `
+            -Filter 'AdapterTypeId=0'                          `
+            -ErrorAction SilentlyContinue |
+            Select-Object -First 1
+  $enc  = Get-CimInstance -ClassName Win32_SystemEnclosure     -ErrorAction Stop
+  $prod = Get-CimInstance -ClassName Win32_ComputerSystemProduct -ErrorAction SilentlyContinue
+  $os   = Get-CimInstance -ClassName Win32_OperatingSystem     -ErrorAction Stop
+  [PSCustomObject]@{
+    vendor          = [string]$cs.Manufacturer
+    model           = [string]$cs.Model
+    system_family   = [string]$cs.SystemFamily
+    friendly_model  = [string]$prod.Name
+    product_version = [string]$prod.Version
+    serial_bios    = [string]$bios.SerialNumber
+    serial_board   = [string]$board.SerialNumber
+    cpu_id         = [string]$cpu.ProcessorId
+    mac            = [string]$nic.MACAddress
+    os_build       = [string]$os.BuildNumber
+    firmware       = [string]$bios.SMBIOSBIOSVersion
+    chassis        = ($enc.ChassisTypes -join ',')
+  } | ConvertTo-Json -Compress
+} catch { Write-Output '{}' }
+"""
+
+_INSTALLED_PS = """\
+Get-CimInstance -ClassName Win32_PnPSignedDriver |
+  Where-Object { $_.HardWareID -and $_.DriverVersion } |
+  Select-Object HardWareID, DriverVersion |
+  ConvertTo-Json -Compress
+"""
+
+
+# ── 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", "")
+        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")
+            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}"
+    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()
+    hwids = []
+    try:
+        r = subprocess.run(
+            ["pnputil", "/enum-devices", "/connected", "/ids"],
+            capture_output=True, text=True,
+            timeout=cfg["timeout_short"],
+        )
+        for line in r.stdout.splitlines():
+            line = line.strip()
+            if "\\" in line and not line.endswith(":"):
+                hwids.append(line.upper())
+    except Exception as e:
+        print(f"[warn] pnputil failed: {e}")
+    return list(set(hwids))
+
+
+def get_model_profile() -> dict:
+    """
+    Return machine profile dict.
+    Tries a single PowerShell call first; falls back to parallel wmic queries.
+    """
+    data = _get_profile_data()
+    if data:
+        return _profile_from_ps(data)
+    return _profile_from_wmic()
+
+
+def get_installed_versions(hwids: list[str]) -> dict[str, str]:
+    """
+    Return {hwid: version_string} for all installed drivers.
+    Tries PowerShell first, falls back to wmic CSV.
+    Caches result keyed by sorted HWID list hash.
+    """
+    cfg       = get()
+    hwid_hash = hashlib.sha256("|".join(sorted(hwids)).encode()).hexdigest()[:16]
+    cache     = _load_versions_cache(cfg, hwid_hash)
+    if cache is not None:
+        return cache
+
+    print("[scan] Querying installed driver versions…")
+    versions = _installed_versions_ps()
+    if not versions:
+        versions = _installed_versions_wmic(cfg)
+
+    _save_versions_cache(cfg, hwid_hash, versions)
+    return versions
+
+
+# ── PowerShell helpers ─────────────────────────────────────────────────────────
+
+def _run_ps(script: str, timeout: int) -> str:
+    """Run a PowerShell script inline. Returns stdout or '' on failure."""
+    try:
+        r = subprocess.run(
+            ["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:
+        return ""
+
+
+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))
+    if not out:
+        return {}
+    try:
+        return json.loads(out)
+    except Exception:
+        return {}
+
+
+def _profile_from_ps(data: dict) -> dict:
+    model = _clean(data.get("model", "Unknown"))
+    # Marketing name: Lenovo (and some others) put the machine-type CODE in
+    # ComputerSystemProduct.Name / ComputerSystem.Model (e.g. "20F1001PUS") and the
+    # 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")):
+        cand = _clean(cand or "")
+        if _is_meaningful(cand) and cand.lower() != model.lower():
+            friendly = cand
+            break
+    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",
+        "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))
+    if not out:
+        return {}
+    try:
+        rows = json.loads(out)
+        if isinstance(rows, dict):
+            rows = [rows]
+        return {
+            row["HardWareID"].upper(): row["DriverVersion"]
+            for row in rows
+            if row.get("HardWareID") and row.get("DriverVersion")
+        }
+    except Exception:
+        return {}
+
+
+# ── 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")
+        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")
+    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",
+        "firmware_version": fw_f.result() or "",
+    }
+
+
+def _installed_versions_wmic(cfg: dict) -> dict[str, str]:
+    versions: dict[str, str] = {}
+    try:
+        r = subprocess.run(
+            ["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()
+                if hwid and ver:
+                    versions[hwid] = ver
+    except Exception as e:
+        print(f"[warn] WMI version query failed: {e}")
+    return versions
+
+
+def _get_serial_wmic() -> str:
+    return _wmic("bios get SerialNumber") or _wmic("baseboard get SerialNumber") or ""
+
+
+def _get_friendly_model_wmic() -> str:
+    name = _wmic("computersystemproduct get Name")
+    if _is_meaningful(name):
+        return name
+    family = _wmic("computersystem get SystemFamily")
+    return family if _is_meaningful(family) else ""
+
+
+def _get_chassis_wmic() -> str:
+    raw = _wmic("systemenclosure get ChassisTypes")
+    return _parse_chassis(raw)
+
+
+def _wmic(query: str) -> str:
+    """Run a wmic query and return the first non-empty value."""
+    cfg = get()
+    try:
+        r = subprocess.run(
+            ["wmic"] + query.split() + ["/format:value"],
+            capture_output=True, text=True,
+            timeout=cfg.get("timeout_tiny", 10),
+        )
+        for line in r.stdout.splitlines():
+            if "=" in line:
+                val = line.split("=", 1)[1].strip()
+                if val:
+                    return val
+    except Exception:
+        pass
+    return ""
+
+
+# ── Chassis parsing ────────────────────────────────────────────────────────────
+
+_LAPTOP_CHASSIS  = {8, 9, 10, 11, 12, 14, 30, 31, 32}
+_DESKTOP_CHASSIS = {3, 4, 5, 6, 7, 13, 15, 16, 35, 36}
+
+
+def _parse_chassis(raw: str) -> str:
+    """Parse chassis type string from either PS ('3,8') or wmic ('{3}') format."""
+    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):
+            return "laptop"
+        if any(n in _DESKTOP_CHASSIS for n in nums):
+            return "desktop"
+    except Exception:
+        pass
+    return "unknown"
+
+
+# ── Shared utilities ───────────────────────────────────────────────────────────
+
+_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:
+    return bool(val) and val.strip().lower() not in _JUNK_VALUES
+
+
+def _clean(val: str) -> str:
+    v = (val or "").strip()
+    return v if _is_meaningful(v) else ""
+
+
+def _safe_int(val: str) -> int:
+    try:
+        return int(val.strip())
+    except (ValueError, AttributeError):
+        return 0
+
+
+def _load_versions_cache(cfg: dict, hwid_hash: str) -> dict | None:
+    path = Path(cfg.get("cache_dir", "C:\\DriverServer\\client")) / "ds_versions_cache.json"
+    if not path.exists():
+        return None
+    try:
+        cached = json.loads(path.read_text())
+        if cached.get("hwid_hash") == hwid_hash:
+            return cached.get("versions", {})
+    except Exception:
+        pass
+    return None
+
+
+def _save_versions_cache(cfg: dict, hwid_hash: str, versions: dict) -> None:
+    path = Path(cfg.get("cache_dir", "C:\\DriverServer\\client")) / "ds_versions_cache.json"
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps({"hwid_hash": hwid_hash, "versions": versions}))
+    except Exception:
+        pass