localcode 0.3.61__tar.gz → 0.3.62__tar.gz

{localcode-0.3.61/src/localcode.egg-info → localcode-0.3.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.61
+Version: 0.3.62
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.61 → localcode-0.3.62}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.61"
+version = "0.3.62"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.61 → localcode-0.3.62}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.3.61"
+    __version__ = "0.3.62"

{localcode-0.3.61 → localcode-0.3.62}/src/localcode/bootstrap.py

@@ -47,6 +47,16 @@ _DOWNLOAD_QUEUE: list[str] = []
 # ModelChoice after waiting in the queue.
 _DOWNLOAD_CHOICES: dict[str, object] = {}
 
+# model_key -> cancel Event. Set by cancel_download; polled by the parallel
+# downloader (and the hub progress hook) so an in-flight transfer aborts
+# promptly instead of running to completion after the user backs out.
+_DOWNLOAD_CANCEL: dict[str, "threading.Event"] = {}
+
+
+class DownloadCancelled(Exception):
+    """Raised inside the download machinery when a cancel Event fires, so the
+    aborted transfer is not reported as a network failure."""
+
 # Max concurrent ACTIVE downloads (status == "downloading"). The rest sit
 # in _DOWNLOAD_QUEUE with status "queued" until a slot frees.
 _MAX_ACTIVE_DOWNLOADS = 2
@@ -418,7 +428,8 @@ def get_model_path(preferred_filename: str | None = None) -> Path | None:
 
 
 def _download_parallel(url: str, dest: Path, num_threads: int = 16,
-                       on_progress: Callable[[str], None] | None = None) -> None:
+                       on_progress: Callable[[str], None] | None = None,
+                       cancel_event: "threading.Event | None" = None) -> None:
     """Download a large file using parallel HTTP range requests.
 
     Falls back to single-threaded if the server doesn't support ranges.
@@ -466,13 +477,25 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
 
     part = dest.with_name(dest.name + ".part")
 
+    if cancel_event is not None and cancel_event.is_set():
+        part.unlink(missing_ok=True)
+        raise DownloadCancelled()
+
     if not total_size or not accepts_ranges:
-        # Fallback: single-threaded
+        # Fallback: single-threaded. The reporthook doubles as the cancel
+        # poll — urlretrieve calls it every block, so raising there stops the
+        # transfer promptly (urlretrieve cleans up its own temp on the raise).
         def _report(block_num, block_size, _total):
+            if cancel_event is not None and cancel_event.is_set():
+                raise DownloadCancelled()
             if on_progress and total_size > 0:
                 done = min(block_num * block_size, total_size)
                 on_progress(f"Downloading: {done // (1024*1024)}/{total_size // (1024*1024)} MB ({done * 100 // total_size}%)")
-        urllib.request.urlretrieve(url, str(part), reporthook=_report)  # no ssl_ctx for urlretrieve
+        try:
+            urllib.request.urlretrieve(url, str(part), reporthook=_report)  # no ssl_ctx for urlretrieve
+        except DownloadCancelled:
+            part.unlink(missing_ok=True)
+            raise
         part.replace(dest)
         return
 
@@ -499,6 +522,11 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
                 with open(part, "r+b") as f:
                     f.seek(start)
                     while True:
+                        # Poll the cancel Event between reads so a cancelled
+                        # download stops writing within one 8MB buffer instead
+                        # of running the chunk to completion.
+                        if cancel_event is not None and cancel_event.is_set():
+                            return
                         data = resp.read(buf_size)
                         if not data:
                             break
@@ -541,6 +569,13 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
     progress_stop.set()
     progress_thread.join(timeout=1)
 
+    # Cancelled mid-flight: the chunk threads have already returned, so just
+    # drop the pre-allocated partial and report the abort. Checked before the
+    # error list so a cancel never surfaces as a chunk RuntimeError.
+    if cancel_event is not None and cancel_event.is_set():
+        part.unlink(missing_ok=True)
+        raise DownloadCancelled()
+
     if errors:
         part.unlink(missing_ok=True)
         raise RuntimeError("; ".join(errors))
@@ -551,6 +586,7 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
 def download_model(
     choice=None,
     on_progress: Callable[[str], None] | None = None,
+    cancel_event: "threading.Event | None" = None,
 ) -> tuple[bool, str]:
     """Download a GGUF model selected from `models_catalog.CHOICES`.
 
@@ -621,6 +657,9 @@ def download_model(
     last_err_category = "unknown"
     backoffs = [0, 2, 5]  # seconds; 3 attempts total
     for attempt, delay in enumerate(backoffs, start=1):
+        # Bail before spending a retry (or its backoff sleep) if cancelled.
+        if cancel_event is not None and cancel_event.is_set():
+            return False, "cancelled"
         if delay:
             if on_progress:
                 on_progress(f"Retry {attempt}/{len(backoffs)} in {delay}s...")
@@ -629,11 +668,13 @@ def download_model(
         # Fast path: huggingface_hub (hf_xet Rust backend on Xet repos).
         # Resumes via the hub's built-in partial-download handling.
         try:
-            if _try_hub_download(choice, model_file, on_progress):
+            if _try_hub_download(choice, model_file, on_progress, cancel_event):
                 ok, reason = _verify_download_integrity(choice, model_file)
                 if not ok:
                     return False, reason
                 return True, str(model_file)
+        except DownloadCancelled:
+            return False, "cancelled"
         except Exception as e:
             last_err = e
             last_err_category = _classify_download_error(e)
@@ -646,11 +687,16 @@ def download_model(
                 )
         # Slow path: tuned urllib parallel downloader.
         try:
-            _download_parallel(url, model_file, num_threads=32, on_progress=on_progress)
+            _download_parallel(
+                url, model_file, num_threads=32,
+                on_progress=on_progress, cancel_event=cancel_event,
+            )
             ok, reason = _verify_download_integrity(choice, model_file)
             if not ok:
                 return False, reason
             return True, str(model_file)
+        except DownloadCancelled:
+            return False, "cancelled"
         except Exception as e:
             last_err = e
             last_err_category = _classify_download_error(e)
@@ -803,14 +849,22 @@ def _maybe_start_next() -> None:
 def _run_download(key: str, choice) -> None:
     """Daemon worker — runs download_model OUTSIDE the lock during I/O."""
     on_progress = lambda line: _apply_progress(key, line)
+    with _DOWNLOAD_LOCK:
+        cancel_event = _DOWNLOAD_CANCEL.get(key)
     try:
-        ok, result = download_model(choice, on_progress=on_progress)
+        ok, result = download_model(
+            choice, on_progress=on_progress, cancel_event=cancel_event
+        )
     except Exception as exc:  # pragma: no cover - defensive; download_model traps its own
         ok, result = False, str(exc)
     try:
         with _DOWNLOAD_LOCK:
             entry = _DOWNLOADS.get(key)
-            if entry is not None:
+            # A cancelled download has already had its entry dropped by
+            # cancel_download; don't resurrect it as "failed".
+            if entry is not None and not (
+                cancel_event is not None and cancel_event.is_set()
+            ):
                 if ok:
                     entry["status"] = "done"
                     entry["progress_pct"] = 100
@@ -859,11 +913,66 @@ def start_background_download(choice) -> str:
             "error": None,
         }
         _DOWNLOAD_CHOICES[key] = choice
+        # Fresh (cleared) cancel Event per download; cancel_download sets it.
+        _DOWNLOAD_CANCEL[key] = threading.Event()
         _DOWNLOAD_QUEUE.append(key)
         _maybe_start_next()
     return key
 
 
+def _delete_partial_files(choice) -> None:
+    """Remove any on-disk bytes for `choice` after a cancel: the final file and
+    the `.part` working file the parallel downloader pre-allocates. A half-
+    written .gguf at the final name would pass the size check on a later run and
+    then fail cryptically inside llama-server, so we delete it outright rather
+    than trust `_is_complete_download` to catch it."""
+    try:
+        dest = Path(choice.local_path)
+    except Exception:
+        return
+    for p in (dest, dest.with_name(dest.name + ".part")):
+        try:
+            p.unlink(missing_ok=True)
+        except Exception:
+            # Best effort — a locked/absent file must never crash the cancel.
+            pass
+
+
+def cancel_download(key: str) -> bool:
+    """Cancel an in-flight (or queued) background download and delete its
+    partial file. Returns True iff there was something to cancel.
+
+    Sets the download's cancel Event (so the worker thread aborts promptly),
+    drops the registry/queue entry so the row reverts to "not downloaded",
+    then removes the partial bytes from disk. Safe to call when nothing is
+    downloading (returns False) and safe to call twice.
+    """
+    with _DOWNLOAD_LOCK:
+        event = _DOWNLOAD_CANCEL.get(key)
+        entry = _DOWNLOADS.get(key)
+        choice = _DOWNLOAD_CHOICES.get(key)
+        # Only queued/downloading entries are cancellable; a done/failed entry
+        # (or no entry at all) means there's nothing in flight to stop.
+        active = entry is not None and entry["status"] in ("queued", "downloading")
+        if event is not None:
+            event.set()
+        if key in _DOWNLOAD_QUEUE:
+            _DOWNLOAD_QUEUE.remove(key)
+        _DOWNLOADS.pop(key, None)
+        _DOWNLOAD_CHOICES.pop(key, None)
+        _DOWNLOAD_CANCEL.pop(key, None)
+    if not active:
+        return False
+    # Disk I/O happens OUTSIDE the lock. Deleting only when the entry was
+    # actually in flight protects a just-completed file from being removed.
+    if choice is not None:
+        _delete_partial_files(choice)
+    # A freed slot may let a queued download start now.
+    with _DOWNLOAD_LOCK:
+        _maybe_start_next()
+    return True
+
+
 def download_status(key: str) -> dict | None:
     """Return a shallow copy of the registry entry for `key`, or None."""
     with _DOWNLOAD_LOCK:
@@ -956,7 +1065,7 @@ def _is_mmproj_complete(p: Path, choice) -> bool:
     return size >= int(expected * 0.9)
 
 
-def _make_progress_tqdm(on_progress: Callable[[str], None]):
+def _make_progress_tqdm(on_progress: Callable[[str], None], cancel_event=None):
     """Build a tqdm subclass that forwards download progress to the UI.
 
     huggingface_hub drives BOTH of its backends — hf_xet (Rust, parallel
@@ -978,6 +1087,11 @@ def _make_progress_tqdm(on_progress: Callable[[str], None]):
             self._lc_last_emit = 0.0
 
         def update(self, n=1):
+            # Cancelling raises out of the hub's write loop — update() is the
+            # one hook driven on every downloaded byte for both backends, so it
+            # is the promptest place to abort the hub path.
+            if cancel_event is not None and cancel_event.is_set():
+                raise DownloadCancelled()
             self._lc_done += int(n or 0)
             now = time.monotonic()
             if now - self._lc_last_emit >= 0.5:
@@ -1003,7 +1117,8 @@ def _make_progress_tqdm(on_progress: Callable[[str], None]):
     return _ProgressTqdm
 
 
-def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | None) -> bool:
+def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | None,
+                      cancel_event=None) -> bool:
     """Try to download via huggingface_hub's resumable HTTP downloader.
 
     The hf_xet backend is deliberately disabled (`HF_HUB_DISABLE_XET=1`
@@ -1020,8 +1135,12 @@ def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | N
         from huggingface_hub import hf_hub_download
     except ImportError:
         return False
+    if cancel_event is not None and cancel_event.is_set():
+        raise DownloadCancelled()
     if on_progress:
         on_progress(f"Downloading {choice.filename} (HuggingFace, accelerated)...")
+    # Always route through our tqdm so the cancel poll fires even when there is
+    # no on_progress sink (the update() hook is what aborts the hub stream).
     downloaded_path = hf_hub_download(
         repo_id=choice.hf_repo,
         filename=choice.filename,
@@ -1030,7 +1149,7 @@ def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | N
         # under the same filename visible instead of silent.
         revision=getattr(choice, "revision", None) or "main",
         local_dir=str(dest.parent),
-        tqdm_class=_make_progress_tqdm(on_progress) if on_progress else None,
+        tqdm_class=_make_progress_tqdm(on_progress or (lambda _l: None), cancel_event),
     )
     # huggingface_hub may write to a slightly different filename inside
     # local_dir; symlink/rename to our expected dest.

{localcode-0.3.61 → localcode-0.3.62}/src/localcode/tui/screens/model_picker.py

@@ -99,6 +99,7 @@ class ModelPickerScreen(Screen):
         Binding("h", "back", "Back", show=False),
         Binding("d", "edit_dir", "Change save directory", show=False),
         Binding("x", "begin_delete", "Delete a downloaded model", show=False),
+        Binding("c", "cancel_download", "Cancel download", show=False),
         Binding("y", "confirm_delete", "Confirm deletion", show=False),
         Binding("n", "cancel_delete", "Abort deletion", show=False),
         Binding("escape", "cancel", "Cancel", show=False),
@@ -266,10 +267,14 @@ class ModelPickerScreen(Screen):
             # so without this the user can't tell which model the quants are for.
             fam = self._open_group.display_name if self._open_group else ""
             fam_bit = f"[dim]·[/] [bold]{fam}[/] " if fam else ""
+            # Surface `c cancel` only while a download is in flight — no point
+            # advertising it on a fully-downloaded quant list.
+            from ... import bootstrap
+            cancel_bit = "c cancel · " if bootstrap.list_active_downloads() else ""
             return (
                 f"[{C.primary}]LocalCode[/] {fam_bit}"
                 "[dim]· ↑/↓ + Enter to select a quant · "
-                "Esc/← back to models[/]"
+                f"{cancel_bit}Esc/← back to models[/]"
             )
         return self._default_footer_markup()
 
@@ -688,13 +693,31 @@ class ModelPickerScreen(Screen):
             return
 
         # A model is already usable — download in the background and stay put so
-        # the user can keep working; the row reflects live progress.
-        bootstrap.start_background_download(choice)
-        self._ensure_progress_timer()
-        self._refresh()
-        self._flash_footer(
-            f"[dim]Downloading {q.label} in the background — pick it again when "
-            "it's ready.[/]"
+        # the user can keep working; the row reflects live progress. Confirm
+        # first: a multi-GB download shouldn't start on a stray Enter. (The
+        # first-run path above dismisses without a modal, since the app has
+        # nothing to run until something is downloaded.)
+        from .confirm import ConfirmScreen
+
+        def _on_confirm(ok: bool, q=q, choice=choice) -> None:
+            if not ok:
+                return
+            bootstrap.start_background_download(choice)
+            self._ensure_progress_timer()
+            self._refresh()
+            self._flash_footer(
+                f"[dim]Downloading {q.label} in the background, pick it again when "
+                "it's ready.[/]"
+            )
+
+        self.app.push_screen(
+            ConfirmScreen(
+                f"Download {q.label}?",
+                f"{q.size_gb:.1f} GB will be downloaded in the background.",
+                confirm_label="Download",
+                dangerous=False,
+            ),
+            _on_confirm,
         )
 
     def _has_usable_model(self) -> bool:
@@ -710,6 +733,33 @@ class ModelPickerScreen(Screen):
             return False
         return cur is not None and bootstrap.is_download_complete(cur)
 
+    def action_cancel_download(self) -> None:
+        """c — cancel the focused quant's in-flight background download and
+        delete its partial file. No-op (with a hint) if it isn't downloading."""
+        inp = self.query_one("#dir-input", Input)
+        if inp.has_class("active"):
+            return
+        # Only meaningful at the quant level, where rows carry download state.
+        if self._level != self._LEVEL_QUANTS:
+            return
+        from ... import bootstrap
+        from ...models_catalog import model_dir
+        rows = self._visible_quants()
+        if not (0 <= self._focused_idx < len(rows)):
+            return
+        q = rows[self._focused_idx]
+        state = self._quant_state(bootstrap, q, model_dir())
+        # A downloading row reads "↓ NN%"; a queued one reads "queued". Anything
+        # else (downloaded / failed / none) has no in-flight download to stop.
+        if not (state.startswith("↓") or state == "queued"):
+            self._flash_footer(
+                "[dim]Nothing to cancel, this quant isn't downloading.[/]"
+            )
+            return
+        bootstrap.cancel_download(q.filename)
+        self._refresh()
+        self._flash_footer(f"[dim]Cancelled download of {q.label}.[/]")
+
     def action_back(self) -> None:
         """Left / h — back out of Level 2 to Level 1 (no-op at Level 1)."""
         inp = self.query_one("#dir-input", Input)

{localcode-0.3.61 → localcode-0.3.62/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.61
+Version: 0.3.62
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.61 → localcode-0.3.62}/src/localcode.egg-info/SOURCES.txt

@@ -1186,6 +1186,7 @@ tests/test_anchor_guard.py
 tests/test_architecture.py
 tests/test_bootstrap.py
 tests/test_brief_result_strips_fence.py
+tests/test_cancel_download.py
 tests/test_chat_worker_cancel.py
 tests/test_checkpoint.py
 tests/test_churn_detection.py

localcode-0.3.62/tests/test_cancel_download.py

@@ -0,0 +1,132 @@
+"""cancel_download: abort an in-flight background download and clean up.
+
+These exercise bootstrap's cancellation directly (no Textual, no network) — a
+mocked/registry-marked download entry plus a partial file on disk, then a call
+to cancel_download. They assert the cancel Event fires, the registry entry is
+dropped, and the partial .gguf is deleted so a later run can never mistake it
+for a complete model.
+"""
+from __future__ import annotations
+
+import sys
+import threading
+from pathlib import Path
+from types import SimpleNamespace
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))
+
+from localcode import bootstrap
+
+
+def _seed_entry(key: str, choice, status: str = "downloading") -> threading.Event:
+    """Register a fake in-flight download and return its cancel Event."""
+    event = threading.Event()
+    with bootstrap._DOWNLOAD_LOCK:
+        bootstrap._DOWNLOADS[key] = {
+            "model_key": key,
+            "name": choice.name,
+            "progress_pct": 23,
+            "downloaded_mb": 100,
+            "total_mb": 7100,
+            "status": status,
+            "error": None,
+        }
+        bootstrap._DOWNLOAD_CHOICES[key] = choice
+        bootstrap._DOWNLOAD_CANCEL[key] = event
+    return event
+
+
+def _cleanup(key: str) -> None:
+    with bootstrap._DOWNLOAD_LOCK:
+        bootstrap._DOWNLOADS.pop(key, None)
+        bootstrap._DOWNLOAD_CHOICES.pop(key, None)
+        bootstrap._DOWNLOAD_CANCEL.pop(key, None)
+        if key in bootstrap._DOWNLOAD_QUEUE:
+            bootstrap._DOWNLOAD_QUEUE.remove(key)
+
+
+def _fake_choice(tmp_path: Path, name: str = "fake-model-cancel-Q4_K_M.gguf"):
+    return SimpleNamespace(
+        filename=name,
+        name="Fake Cancel Model",
+        local_path=tmp_path / name,
+        size_gb=7.1,
+        hf_repo="fake/repo",
+        revision=None,
+    )
+
+
+def test_cancel_download_running_entry_cleans_up(tmp_path):
+    choice = _fake_choice(tmp_path)
+    key = choice.filename
+    # A partial file (final name) and its .part working file on disk.
+    (tmp_path / key).write_bytes(b"\0" * 1024)
+    (tmp_path / (key + ".part")).write_bytes(b"\0" * 2048)
+    event = _seed_entry(key, choice)
+    try:
+        result = bootstrap.cancel_download(key)
+        assert result is True
+        # Cancel Event fired so any worker thread would abort.
+        assert event.is_set()
+        # Registry entry (and its cancel/choice bookkeeping) is gone.
+        assert bootstrap.download_status(key) is None
+        with bootstrap._DOWNLOAD_LOCK:
+            assert key not in bootstrap._DOWNLOAD_CANCEL
+            assert key not in bootstrap._DOWNLOAD_CHOICES
+        # Both the partial and the .part working file are deleted.
+        assert not (tmp_path / key).exists()
+        assert not (tmp_path / (key + ".part")).exists()
+    finally:
+        _cleanup(key)
+
+
+def test_cancel_download_when_nothing_downloading_returns_false():
+    # No registry entry for this key at all.
+    assert bootstrap.cancel_download("no-such-model-xyz.gguf") is False
+
+
+def test_cancel_download_queued_entry_is_removed_from_queue(tmp_path):
+    choice = _fake_choice(tmp_path, "fake-queued-Q4.gguf")
+    key = choice.filename
+    (tmp_path / key).write_bytes(b"\0" * 512)
+    event = _seed_entry(key, choice, status="queued")
+    with bootstrap._DOWNLOAD_LOCK:
+        bootstrap._DOWNLOAD_QUEUE.append(key)
+    try:
+        assert bootstrap.cancel_download(key) is True
+        assert event.is_set()
+        with bootstrap._DOWNLOAD_LOCK:
+            assert key not in bootstrap._DOWNLOAD_QUEUE
+        assert bootstrap.download_status(key) is None
+        assert not (tmp_path / key).exists()
+    finally:
+        _cleanup(key)
+
+
+def test_cancel_download_does_not_delete_a_completed_file(tmp_path):
+    """A cancel on a just-finished download must NOT delete the good file."""
+    choice = _fake_choice(tmp_path, "fake-done-Q4.gguf")
+    key = choice.filename
+    good = tmp_path / key
+    good.write_bytes(b"\0" * 4096)
+    _seed_entry(key, choice, status="done")
+    try:
+        # Nothing in flight (status done) → returns False, file preserved.
+        assert bootstrap.cancel_download(key) is False
+        assert good.exists()
+    finally:
+        _cleanup(key)
+
+
+def test_download_model_aborts_immediately_when_cancel_preset(tmp_path):
+    """download_model with an already-set cancel Event returns ("cancelled")
+    before touching the network."""
+    choice = _fake_choice(tmp_path, "fake-preset-cancel-Q4.gguf")
+    choice.size_gb = 0.001  # keep the disk-space preflight trivially satisfied
+    event = threading.Event()
+    event.set()
+    ok, result = bootstrap.download_model(
+        choice, on_progress=None, cancel_event=event
+    )
+    assert ok is False
+    assert result == "cancelled"

{localcode-0.3.61 → localcode-0.3.62}/tests/test_comprehensive_bg_download.py

@@ -93,7 +93,7 @@ def test_start_registers_downloading_entry_and_returns_key(monkeypatch, not_on_d
     """
     release = threading.Event()
 
-    def _gated_download(choice, on_progress=None):
+    def _gated_download(choice, on_progress=None, cancel_event=None):
         release.wait(timeout=3.0)
         return True, str(choice.local_path)
 
@@ -118,7 +118,7 @@ def test_download_status_has_documented_shape(monkeypatch, not_on_disk):
     release = threading.Event()
     monkeypatch.setattr(
         bootstrap, "download_model",
-        lambda choice, on_progress=None: (release.wait(timeout=3.0), (True, str(choice.local_path)))[1],
+        lambda choice, on_progress=None, cancel_event=None: (release.wait(timeout=3.0), (True, str(choice.local_path)))[1],
     )
 
     choice = _choice()
@@ -153,7 +153,7 @@ def test_concurrency_cap_leaves_extras_queued(monkeypatch, not_on_disk):
 
     release = threading.Event()
 
-    def _gated_download(choice, on_progress=None):
+    def _gated_download(choice, on_progress=None, cancel_event=None):
         release.wait(timeout=5.0)
         return True, str(choice.local_path)
 
@@ -197,7 +197,7 @@ def test_completed_download_flips_to_done(monkeypatch, not_on_disk):
     with progress_pct pinned at 100 and no error."""
     monkeypatch.setattr(
         bootstrap, "download_model",
-        lambda choice, on_progress=None: (True, str(choice.local_path)),
+        lambda choice, on_progress=None, cancel_event=None: (True, str(choice.local_path)),
     )
 
     choice = _choice()
@@ -216,7 +216,7 @@ def test_failed_download_records_error(monkeypatch, not_on_disk):
     """A failing download_model leaves the entry 'failed' with the message."""
     monkeypatch.setattr(
         bootstrap, "download_model",
-        lambda choice, on_progress=None: (False, "boom: network down"),
+        lambda choice, on_progress=None, cancel_event=None: (False, "boom: network down"),
     )
 
     choice = _choice()

{localcode-0.3.61 → localcode-0.3.62}/tests/test_comprehensive_download.py

@@ -84,7 +84,7 @@ def test_already_downloaded_short_circuits(isolated_model_dir, monkeypatch):
 def test_fast_path_success(isolated_model_dir, monkeypatch):
     choice = _unpinned(catalog.by_key("gemma-12b"))
 
-    def _fake_hf(c, model_file, on_progress=None):
+    def _fake_hf(c, model_file, on_progress=None, cancel_event=None):
         Path(model_file).write_bytes(b"downloaded")
         return True
 
@@ -158,7 +158,7 @@ def test_partial_at_final_name_is_not_treated_as_done(isolated_model_dir, monkey
     choice.local_path.write_bytes(b"partial junk")
     completed = {"hub": False}
 
-    def _fake_hub(c, model_file, on_progress=None):
+    def _fake_hub(c, model_file, on_progress=None, cancel_event=None):
         # Simulate the hub finishing the download at full size.
         Path(model_file).write_bytes(b"x" * 1024)
         monkeypatch.setattr(bootstrap, "_is_complete_download", lambda p, e: True)