driverclient 0.2.32__tar.gz → 0.2.33__tar.gz

{driverclient-0.2.32 → driverclient-0.2.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driverclient
-Version: 0.2.32
+Version: 0.2.33
 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>
@@ -203,3 +203,34 @@ class Panel:
 
 - Python >= 3.10
 - Windows target for the actual driver operations (`pnputil`, WMI, DISM).
+
+## Building & releasing
+
+The version lives in `pyproject.toml` **and** `src/driverclient/__init__.py` (kept
+in lockstep by `bump_version.py`). System Assistant consumes this as a pip package
+(`driverclient>=X` in its `requirements.txt`), so a code change ships by publishing
+a **new version** — PyPI never overwrites an existing one.
+
+### With uv (no extra tooling to install)
+
+`uv build` runs the hatchling backend in an isolated env; `uvx` runs `twine`
+ephemerally — neither needs a pre-installed `build`/`twine`.
+
+```bash
+cd client-package
+uv build                 # → dist/driverclient-<version>-py3-none-any.whl (+ .tar.gz)
+uvx twine upload dist/*  # publish (uses ~/.pypirc)
+```
+
+### Bump vs. no-bump — pick the right one
+
+- **Version NOT set yet** → bump then build:
+  `make release VERSION_PART=patch|minor|major` (bump → build → smoke, no upload),
+  then `twine upload dist/*` (or `uvx twine upload dist/*`).
+- **Version already set to the exact target** (e.g. someone set it by hand): build
+  **without** bumping — `uv build` (or `make clean && make build`), then upload.
+  Do **not** run `make release`/`bump_version.py` here — it would bump *past* the
+  intended version.
+
+Full flow (TestPyPI dry-run, `.pypirc` token, post-publish verify): see
+[RELEASING.md](RELEASING.md).

{driverclient-0.2.32 → driverclient-0.2.33}/README.md

@@ -187,3 +187,34 @@ class Panel:
 
 - Python >= 3.10
 - Windows target for the actual driver operations (`pnputil`, WMI, DISM).
+
+## Building & releasing
+
+The version lives in `pyproject.toml` **and** `src/driverclient/__init__.py` (kept
+in lockstep by `bump_version.py`). System Assistant consumes this as a pip package
+(`driverclient>=X` in its `requirements.txt`), so a code change ships by publishing
+a **new version** — PyPI never overwrites an existing one.
+
+### With uv (no extra tooling to install)
+
+`uv build` runs the hatchling backend in an isolated env; `uvx` runs `twine`
+ephemerally — neither needs a pre-installed `build`/`twine`.
+
+```bash
+cd client-package
+uv build                 # → dist/driverclient-<version>-py3-none-any.whl (+ .tar.gz)
+uvx twine upload dist/*  # publish (uses ~/.pypirc)
+```
+
+### Bump vs. no-bump — pick the right one
+
+- **Version NOT set yet** → bump then build:
+  `make release VERSION_PART=patch|minor|major` (bump → build → smoke, no upload),
+  then `twine upload dist/*` (or `uvx twine upload dist/*`).
+- **Version already set to the exact target** (e.g. someone set it by hand): build
+  **without** bumping — `uv build` (or `make clean && make build`), then upload.
+  Do **not** run `make release`/`bump_version.py` here — it would bump *past* the
+  intended version.
+
+Full flow (TestPyPI dry-run, `.pypirc` token, post-publish verify): see
+[RELEASING.md](RELEASING.md).

{driverclient-0.2.32 → driverclient-0.2.33}/pyproject.toml

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

{driverclient-0.2.32 → driverclient-0.2.33}/src/driverclient/__init__.py

@@ -26,7 +26,7 @@ from driverclient.main import run as _run
 
 __all__ = ["ClientEvent", "DriverClient"]
 
-__version__ = "0.2.32"
+__version__ = "0.2.33"
 
 
 class DriverClient:

{driverclient-0.2.32 → driverclient-0.2.33}/src/driverclient/config.py

@@ -94,6 +94,13 @@ DEFAULTS: dict = {
     # 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,
+    # When the repo doesn't yet have a file (it returns HTTP 503 + Retry-After
+    # while it repairs/pulls that file from upstream), how long the client waits
+    # for the file to become available before giving up on that download. Bounds
+    # the per-file wait so a genuinely-absent file can't hang the pass. Raise it
+    # on slow inter-site links where a large driver (Intel/AMD GPU) is still
+    # syncing down; the client re-polls honoring the server's Retry-After.
+    "download_repair_wait_seconds": 300,
     # ── HTTP timeouts (seconds) ───────────────────────────────────────────
     "timeout_tiny": 10,
     "timeout_short": 30,

{driverclient-0.2.32 → driverclient-0.2.33}/src/driverclient/core/http.py

@@ -222,50 +222,75 @@ def http_download(url: str, dest: Path, sha256_expected: str, timeout: int | Non
     dest.parent.mkdir(parents=True, exist_ok=True)
 
     tmp = dest.with_suffix(dest.suffix + ".part")
-    try:
-        with urllib.request.urlopen(req, timeout=t) as resp:
-            encoding = resp.headers.get("Content-Encoding", "")
-            content_length = resp.headers.get("Content-Length")
-            total = int(content_length) if content_length else None
-
-            hasher = hashlib.sha256()
-            received = 0
-
-            if encoding == "zstd":
+    hasher = hashlib.sha256()
+    received = 0
+    # A missing file on the repo is NOT a hard failure: the server returns 503 +
+    # Retry-After while it repairs the file from upstream (files.py on-demand
+    # repair). Wait out the repair honoring Retry-After instead of the old
+    # fast 3-try give-up — otherwise a big driver still syncing down (e.g. the
+    # ~1.3 GB Intel GPU) fails to download and never installs/binds. Bounded by
+    # download_repair_wait_seconds so a genuinely-absent file can't hang forever.
+    repair_deadline = time.monotonic() + float(cfg.get("download_repair_wait_seconds", 300))
+    while True:
+        hasher = hashlib.sha256()
+        received = 0
+        try:
+            with urllib.request.urlopen(req, timeout=t) as resp:
+                encoding = resp.headers.get("Content-Encoding", "")
+                content_length = resp.headers.get("Content-Length")
+                total = int(content_length) if content_length else None
+
+                if encoding == "zstd":
+                    try:
+                        import zstandard as zstd
+                    except ImportError:
+                        print(
+                            f"  [ERROR] zstandard package required to decompress {dest.name} "
+                            "— install it with: pip install zstandard"
+                        )
+                        return False
+
+                    dctx = zstd.ZstdDecompressor()
+                    with (
+                        open(tmp, "wb") as fh,
+                        dctx.stream_writer(fh, closefd=False) as writer,
+                    ):
+                        while chunk := resp.read(_CHUNK):
+                            writer.write(chunk)
+                            received += len(chunk)
+                            _print_progress(dest.name, received, total)
+
+                    with open(tmp, "rb") as rfh:
+                        while chunk := rfh.read(_CHUNK):
+                            hasher.update(chunk)
+                else:
+                    with open(tmp, "wb") as fh:
+                        while chunk := resp.read(_CHUNK):
+                            fh.write(chunk)
+                            hasher.update(chunk)
+                            received += len(chunk)
+                            _print_progress(dest.name, received, total)
+            break  # streamed OK — fall through to hash verification
+        except urllib.error.HTTPError as e:
+            if e.code == 503 and time.monotonic() < repair_deadline:
                 try:
-                    import zstandard as zstd
-                except ImportError:
-                    print(
-                        f"  [ERROR] zstandard package required to decompress {dest.name} "
-                        "— install it with: pip install zstandard"
-                    )
-                    return False
-
-                dctx = zstd.ZstdDecompressor()
-                with (
-                    open(tmp, "wb") as fh,
-                    dctx.stream_writer(fh, closefd=False) as writer,
-                ):
-                    while chunk := resp.read(_CHUNK):
-                        writer.write(chunk)
-                        received += len(chunk)
-                        _print_progress(dest.name, received, total)
-
-                with open(tmp, "rb") as rfh:
-                    while chunk := rfh.read(_CHUNK):
-                        hasher.update(chunk)
-            else:
-                with open(tmp, "wb") as fh:
-                    while chunk := resp.read(_CHUNK):
-                        fh.write(chunk)
-                        hasher.update(chunk)
-                        received += len(chunk)
-                        _print_progress(dest.name, received, total)
-
-    except Exception as e:
-        tmp.unlink(missing_ok=True)
-        print(f"  [ERROR] Download failed {dest.name}: {e}")
-        return False
+                    wait = float(e.headers.get("Retry-After", "15"))
+                except (TypeError, ValueError):
+                    wait = 15.0
+                tmp.unlink(missing_ok=True)
+                print(
+                    f"  [repair] {dest.name} not on repo yet (503) — repo is fetching it "
+                    f"from upstream, waiting {wait:.0f}s then retrying…"
+                )
+                time.sleep(wait)
+                continue
+            tmp.unlink(missing_ok=True)
+            print(f"  [ERROR] Download failed {dest.name}: HTTP {e.code}")
+            return False
+        except Exception as e:
+            tmp.unlink(missing_ok=True)
+            print(f"  [ERROR] Download failed {dest.name}: {e}")
+            return False
 
     actual = hasher.hexdigest()
     if actual != sha256_expected: