aider-vision-core 0.90.8.dev0__tar.gz → 0.90.9.dev1__tar.gz

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-vision-core
-Version: 0.90.8.dev0
+Version: 0.90.9.dev1
 Summary: aider-vision-core: Aider fork with headless API, submodule git, and web integration
 Project-URL: Homepage, https://github.com/Digital-Defiance/aider-vision-core
 Classifier: Development Status :: 4 - Beta

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.90.8.dev0'
-__version_tuple__ = version_tuple = (0, 90, 8, 'dev0')
+__version__ = version = '0.90.9.dev1'
+__version_tuple__ = version_tuple = (0, 90, 9, 'dev1')
 
-__commit_id__ = commit_id = 'g3b5ad9f66'
+__commit_id__ = commit_id = 'g9eda8d7c6'

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/event_io.py

@@ -29,6 +29,9 @@ class EventIO(InputOutput):
     ):
         kwargs.setdefault("fancy_input", False)
         kwargs.setdefault("pretty", False)
+        self.on_event = on_event
+        self.echo_to_console = echo_to_console
+        self.events: list[dict[str, Any]] = []
         self._null_sink: TextIO | None = None
         if not echo_to_console and kwargs.get("output") is None:
             self._null_sink = open(os.devnull, "w", encoding="utf-8")
@@ -42,9 +45,6 @@ class EventIO(InputOutput):
         # InputOutput attaches Console to stdout; when the desktop app spawns core with
         # stdout closed, Rich writes raise BrokenPipeError.
         self.console = Console(file=sink, force_terminal=False, no_color=True)
-        self.on_event = on_event
-        self.echo_to_console = echo_to_console
-        self.events: list[dict[str, Any]] = []
 
     def emit(self, event_type: str, **payload: Any) -> dict[str, Any]:
         event = {"type": event_type, **payload}
@@ -53,6 +53,27 @@ class EventIO(InputOutput):
             self.on_event(event)
         return event
 
+    def emit_progress(
+        self,
+        *,
+        label: str,
+        current: int | None = None,
+        total: int | None = None,
+        message: str | None = None,
+        fraction: float | None = None,
+    ) -> dict[str, Any]:
+        from aider_vision_core.gui_progress import emit_progress
+
+        emit_progress(
+            self,
+            label=label,
+            current=current,
+            total=total,
+            message=message,
+            fraction=fraction,
+        )
+        return self.events[-1] if self.events else {"type": "progress", "label": label}
+
     def drain_events(self) -> list[dict[str, Any]]:
         events = self.events
         self.events = []

aider_vision_core-0.90.9.dev1/aider_vision_core/gui_progress.py

@@ -0,0 +1,94 @@
+"""
+Progress reporting for Aider Vision (headless / GUI).
+
+Replaces terminal tqdm bars with structured ``progress`` events on EventIO.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Callable, Iterable, Iterator, TypeVar
+
+T = TypeVar("T")
+
+
+def headless_enabled() -> bool:
+    from aider_vision_core.headless_stdio import headless_enabled as _headless_enabled
+
+    return _headless_enabled()
+
+
+def emit_progress(
+    io: Any,
+    *,
+    label: str,
+    current: int | None = None,
+    total: int | None = None,
+    message: str | None = None,
+    fraction: float | None = None,
+) -> None:
+    if io is None:
+        return
+    emit = getattr(io, "emit", None)
+    if not callable(emit):
+        return
+    if fraction is None and current is not None and total:
+        fraction = max(0.0, min(1.0, current / total))
+    payload: dict[str, Any] = {"label": label}
+    if current is not None:
+        payload["current"] = current
+    if total is not None:
+        payload["total"] = total
+    if fraction is not None:
+        payload["fraction"] = fraction
+    if message is not None:
+        payload["message"] = message
+    elif current is not None and total is not None:
+        payload["message"] = f"{current}/{total}"
+    emit("progress", **payload)
+
+
+def should_use_gui_progress(io: Any) -> bool:
+    if io is None:
+        return headless_enabled()
+    if headless_enabled():
+        return True
+    return callable(getattr(io, "emit", None))
+
+
+def progress_iter(
+    iterable: Iterable[T],
+    *,
+    desc: str = "Working",
+    io: Any = None,
+    total: int | None = None,
+    min_items_for_bar: int = 100,
+) -> Iterator[T]:
+    """
+    Iterate with tqdm in the CLI, or ``progress`` events for Vision / EventIO.
+    """
+    if total is None:
+        try:
+            total = len(iterable)  # type: ignore[arg-type]
+        except TypeError:
+            total = None
+
+    use_gui = should_use_gui_progress(io)
+
+    if use_gui and io is not None:
+        throttle = max(1, (total or 1) // 80)
+        for i, item in enumerate(iterable, start=1):
+            if total is None or i == 1 or i >= total or i % throttle == 0:
+                emit_progress(io, label=desc, current=i, total=total)
+            yield item
+        if total is not None:
+            emit_progress(io, label=desc, current=total, total=total)
+        return
+
+    if not use_gui and total is not None and total > min_items_for_bar:
+        from tqdm import tqdm
+
+        yield from tqdm(iterable, desc=desc, total=total)
+        return
+
+    yield from iterable

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/http_api.py

@@ -25,9 +25,9 @@ from pydantic import BaseModel, Field
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request
 
-from aider_vision_core.headless_stdio import install_headless_stdio
+from aider_vision_core.vision_runtime import configure_vision_runtime
 
-install_headless_stdio()
+configure_vision_runtime()
 
 from aider_vision_core.git_undo import undo_last_aider_commit_for_coder
 from aider_vision_core.http_auth import auth_enabled, configure_auth, get_token_from_env, verify_bearer

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/repomap.py

@@ -15,11 +15,18 @@ from diskcache import Cache
 from grep_ast import TreeContext, filename_to_lang
 from pygments.lexers import guess_lexer_for_filename
 from pygments.token import Token
-from tqdm import tqdm
 from tree_sitter import Query
 
 from aider_vision_core.dump import dump
+from aider_vision_core.gui_progress import progress_iter
 from aider_vision_core.special import filter_important_files
+from aider_vision_core.vision_runtime import (
+    CACHE_LOAD_ERRORS,
+    REPO_MAP_CACHE_DIRNAME,
+    REPO_MAP_CACHE_VERSION,
+    purge_legacy_tag_caches,
+    safe_cache_len,
+)
 from aider_vision_core.waiting import Spinner
 
 # tree_sitter is throwing a FutureWarning
@@ -30,17 +37,14 @@ Tag = namedtuple("Tag", "rel_fname fname line name kind".split())
 
 
 SQLITE_ERRORS = (sqlite3.OperationalError, sqlite3.DatabaseError, OSError)
-
-
-CACHE_VERSION = 3
-if USING_TSL_PACK:
-    CACHE_VERSION = 4
+# Re-export for tests / callers
+CACHE_VERSION = REPO_MAP_CACHE_VERSION
 
 UPDATING_REPO_MAP_MESSAGE = "Updating repo map"
 
 
 class RepoMap:
-    TAGS_CACHE_DIR = f".aider.tags.cache.v{CACHE_VERSION}"
+    TAGS_CACHE_DIR = REPO_MAP_CACHE_DIRNAME
 
     warned_files = set()
 
@@ -215,6 +219,7 @@ class RepoMap:
         self.TAGS_CACHE = dict()
 
     def load_tags_cache(self):
+        purge_legacy_tag_caches(self.root)
         path = Path(self.root) / self.TAGS_CACHE_DIR
         try:
             self.TAGS_CACHE = Cache(path)
@@ -239,14 +244,14 @@ class RepoMap:
         cache_key = fname
         try:
             val = self.TAGS_CACHE.get(cache_key)  # Issue #1308
-        except SQLITE_ERRORS as e:
+        except CACHE_LOAD_ERRORS as e:
             self.tags_cache_error(e)
             val = self.TAGS_CACHE.get(cache_key)
 
         if val is not None and val.get("mtime") == file_mtime:
             try:
                 return self.TAGS_CACHE[cache_key]["data"]
-            except SQLITE_ERRORS as e:
+            except CACHE_LOAD_ERRORS as e:
                 self.tags_cache_error(e)
                 return self.TAGS_CACHE[cache_key]["data"]
 
@@ -289,7 +294,7 @@ class RepoMap:
             return
 
         query_scm = get_scm_fname(lang)
-        if not query_scm.exists():
+        if not query_scm or not query_scm.exists():
             return
         query_scm = query_scm.read_text()
 
@@ -382,22 +387,24 @@ class RepoMap:
         # https://networkx.org/documentation/stable/_modules/networkx/algorithms/link_analysis/pagerank_alg.html#pagerank
         personalize = 100 / len(fnames)
 
-        try:
-            cache_size = len(self.TAGS_CACHE)
-        except SQLITE_ERRORS as e:
-            self.tags_cache_error(e)
-            cache_size = len(self.TAGS_CACHE)
+        cache_size = safe_cache_len(self.TAGS_CACHE)
+        if cache_size < 0:
+            self.tags_cache_error()
+            cache_size = safe_cache_len(self.TAGS_CACHE)
 
         if len(fnames) - cache_size > 100:
             self.io.tool_output(
                 "Initial repo scan can be slow in larger repos, but only happens once."
             )
-            fnames = tqdm(fnames, desc="Scanning repo")
+            fname_source = progress_iter(
+                fnames, desc="Scanning repo", io=self.io, total=len(fnames)
+            )
             showing_bar = True
         else:
+            fname_source = fnames
             showing_bar = False
 
-        for fname in fnames:
+        for fname in fname_source:
             if self.verbose:
                 self.io.tool_output(f"Processing {fname}")
             if progress and not showing_bar:
@@ -643,7 +650,7 @@ class RepoMap:
         if not mentioned_idents:
             mentioned_idents = set()
 
-        spin = Spinner(UPDATING_REPO_MAP_MESSAGE)
+        spin = Spinner(UPDATING_REPO_MAP_MESSAGE, io=self.io)
 
         ranked_tags = self.get_ranked_tags(
             chat_fnames,
@@ -803,30 +810,30 @@ def get_random_color():
 
 
 def get_scm_fname(lang):
-    # Load the tags queries
+    # Load tags queries from the aider_vision_core package root (not this submodule).
+    pkg = __package__.split(".")[0] if __package__ else "aider_vision_core"
     if USING_TSL_PACK:
         subdir = "tree-sitter-language-pack"
         try:
-            path = resources.files(__package__).joinpath(
+            path = resources.files(pkg).joinpath(
                 "queries",
                 subdir,
                 f"{lang}-tags.scm",
             )
             if path.exists():
                 return path
-        except KeyError:
+        except (KeyError, ModuleNotFoundError, TypeError):
             pass
 
-    # Fall back to tree-sitter-languages
     subdir = "tree-sitter-languages"
     try:
-        return resources.files(__package__).joinpath(
+        return resources.files(pkg).joinpath(
             "queries",
             subdir,
             f"{lang}-tags.scm",
         )
-    except KeyError:
-        return
+    except (KeyError, ModuleNotFoundError, TypeError):
+        return None
 
 
 def get_supported_languages_md():

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/session.py

@@ -52,6 +52,11 @@ class Session:
         if not workspace.is_dir():
             raise FileNotFoundError(f"Workspace not found: {workspace}")
 
+        from aider_vision_core.vision_runtime import configure_vision_runtime, purge_legacy_tag_caches
+
+        configure_vision_runtime()
+        purge_legacy_tag_caches(workspace)
+
         prev_cwd = os.getcwd()
         os.chdir(workspace)
         try:
@@ -119,6 +124,8 @@ class Session:
                 return
 
             for chunk in self.coder.send_message(user_msg):
+                for event in self.io.drain_events():
+                    yield event
                 if chunk:
                     assistant_text.append(chunk)
                     event = self.io.emit("token", text=chunk)

aider_vision_core-0.90.9.dev1/aider_vision_core/vision_runtime.py

@@ -0,0 +1,127 @@
+"""
+Vision / headless runtime setup and guards against legacy ``aider`` rename issues.
+
+Call :func:`configure_vision_runtime` when starting the HTTP API or any headless
+session so TUI output and stale on-disk caches do not leak into the desktop GUI.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+import re
+import shutil
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+# Bump when repo-map tag cache schema or Python package name changes.
+REPO_MAP_CACHE_VERSION = 5
+REPO_MAP_CACHE_DIRNAME = f".aider.tags.cache.v{REPO_MAP_CACHE_VERSION}"
+LEGACY_PYTHON_PACKAGE = "aider"
+LEGACY_TAG_CACHE_PATTERN = re.compile(r"^\.aider\.tags\.cache\.v(\d+)$")
+
+SQLITE_ERRORS = (sqlite3.OperationalError, sqlite3.DatabaseError, OSError)
+CACHE_LOAD_ERRORS = SQLITE_ERRORS + (
+    ModuleNotFoundError,
+    AttributeError,
+    pickle.UnpicklingError,
+)
+
+_tqdm_patched = False
+_runtime_configured = False
+
+
+def headless_enabled() -> bool:
+    from aider_vision_core.headless_stdio import headless_enabled as _he
+
+    return _he()
+
+
+def purge_legacy_tag_caches(root: str | Path) -> list[str]:
+    """
+    Remove repo-map cache dirs from older package names / cache versions.
+
+    Pickled entries may reference the pre-rename ``aider`` module and raise
+    ``ModuleNotFoundError`` when loaded under ``aider_vision_core``.
+    """
+    root = Path(root)
+    removed: list[str] = []
+    if not root.is_dir():
+        return removed
+    for path in sorted(root.iterdir()):
+        if not path.is_dir():
+            continue
+        m = LEGACY_TAG_CACHE_PATTERN.match(path.name)
+        if not m:
+            continue
+        if path.name == REPO_MAP_CACHE_DIRNAME:
+            continue
+        try:
+            shutil.rmtree(path)
+            removed.append(str(path))
+        except OSError:
+            pass
+    return removed
+
+
+def safe_cache_len(cache: Any) -> int:
+    """``len(diskcache.Cache)`` can unpickle entries; treat failures as empty."""
+    try:
+        return len(cache)
+    except CACHE_LOAD_ERRORS:
+        return -1
+
+
+def configure_vision_runtime(*, force: bool = False) -> None:
+    """
+    One-time setup for Aider Vision desktop / API child processes.
+
+    - Redirect stdio (headless)
+    - Disable tqdm terminal bars
+    - Patch tqdm → GUI progress when still invoked from legacy call sites
+    """
+    global _runtime_configured, _tqdm_patched
+    if _runtime_configured and not force:
+        return
+    _runtime_configured = True
+
+    if not headless_enabled():
+        return
+
+    os.environ.setdefault("TQDM_DISABLE", "1")
+
+    from aider_vision_core.headless_stdio import install_headless_stdio
+
+    install_headless_stdio()
+    _patch_tqdm_for_headless()
+
+
+def _patch_tqdm_for_headless() -> None:
+    global _tqdm_patched
+    if _tqdm_patched:
+        return
+    try:
+        import tqdm as tqdm_mod
+    except ImportError:
+        return
+
+    _orig = tqdm_mod.tqdm
+
+    def _vision_tqdm(iterable=None, *args, **kwargs):
+        if iterable is None:
+            return _orig(*args, **kwargs)
+        from aider_vision_core.gui_progress import progress_iter
+
+        desc = kwargs.get("desc")
+        if desc is None and args and isinstance(args[0], str):
+            desc = args[0]
+        return progress_iter(
+            iterable,
+            desc=str(desc or "Working"),
+            io=kwargs.get("io"),
+            total=kwargs.get("total"),
+        )
+
+    tqdm_mod.tqdm = _vision_tqdm
+    _tqdm_patched = True

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/vision_serve.py

@@ -33,10 +33,10 @@ def run(argv: list[str] | None = None) -> None:
     validate_listen_address(args.host)
     configure_auth(args.host)
 
-    if os.environ.get("AIDER_VISION_HEADLESS") == "1":
-        from aider_vision_core.headless_stdio import install_headless_stdio
+    from aider_vision_core.vision_runtime import configure_vision_runtime
 
-        install_headless_stdio()
+    if os.environ.get("AIDER_VISION_HEADLESS") == "1":
+        configure_vision_runtime()
     else:
         print(startup_message(args.host))
 

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core/waiting.py

@@ -35,8 +35,9 @@ class Spinner:
 
     last_frame_idx = 0  # Class variable to store the last frame index
 
-    def __init__(self, text: str, width: int = 7):
+    def __init__(self, text: str, width: int = 7, io=None):
         self.text = text
+        self.io = io
         self.start_time = time.time()
         self.last_update = 0.0
         self.visible = False
@@ -111,6 +112,12 @@ class Spinner:
         if text is not None:
             self.text = text
 
+        if _headless() and self.io is not None:
+            from aider_vision_core.gui_progress import emit_progress
+
+            emit_progress(self.io, label=self.text, message=text or self.text, fraction=None)
+            return
+
         if not self.is_tty:
             return
 

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aider-vision-core
-Version: 0.90.8.dev0
+Version: 0.90.9.dev1
 Summary: aider-vision-core: Aider fork with headless API, submodule git, and web integration
 Project-URL: Homepage, https://github.com/Digital-Defiance/aider-vision-core
 Classifier: Development Status :: 4 - Beta

{aider_vision_core-0.90.8.dev0 → aider_vision_core-0.90.9.dev1}/aider_vision_core.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ aider_vision_core/format_settings.py
 aider_vision_core/git_undo.py
 aider_vision_core/git_workspace.py
 aider_vision_core/gui.py
+aider_vision_core/gui_progress.py
 aider_vision_core/headless_stdio.py
 aider_vision_core/help.py
 aider_vision_core/help_pats.py
@@ -68,6 +69,7 @@ aider_vision_core/special.py
 aider_vision_core/urls.py
 aider_vision_core/utils.py
 aider_vision_core/versioncheck.py
+aider_vision_core/vision_runtime.py
 aider_vision_core/vision_serve.py
 aider_vision_core/voice.py
 aider_vision_core/waiting.py
@@ -307,6 +309,7 @@ requirements/tree-sitter.in
 scripts/30k-image.py
 scripts/Dockerfile.jekyll
 scripts/__init__.py
+scripts/audit_rename_compat.py
 scripts/blame.py
 scripts/clean_metadata.py
 scripts/dl_icons.py
@@ -362,6 +365,7 @@ tests/basic/test_ssl_verification.py
 tests/basic/test_udiff.py
 tests/basic/test_urls.py
 tests/basic/test_utils.py
+tests/basic/test_vision_runtime.py
 tests/basic/test_voice.py
 tests/basic/test_watch.py
 tests/basic/test_wholefile.py

aider_vision_core-0.90.9.dev1/scripts/audit_rename_compat.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+CI / dev audit: catch regressions from the aider → aider_vision_core rename.
+
+Usage:
+    python scripts/audit_rename_compat.py
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+PKG = ROOT / "aider_vision_core"
+SKIP_DIRS = {
+    "website",
+    "__pycache__",
+    ".git",
+}
+SKIP_FILES = {
+    "audit_rename_compat.py",
+}
+
+# `from aider.` / `import aider` but not aider_vision_core / aiderignore / …
+BAD_IMPORT = re.compile(
+    r"^\s*(?:from|import)\s+aider(?!_vision_core|ignore|_edited|_commit|@)",
+)
+# tqdm( in production code — allow gui_progress + search_replace __main__
+BAD_TQDM = re.compile(r"\btqdm\s*\(")
+ALLOW_TQDM = {
+    PKG / "gui_progress.py",
+    PKG / "coders" / "search_replace.py",
+}
+# resources.files(__package__) under repomap breaks query paths
+BAD_RESOURCES = re.compile(r"resources\.files\(\s*__package__\s*\)")
+
+
+def iter_py_files() -> list[Path]:
+    out: list[Path] = []
+    for path in PKG.rglob("*.py"):
+        if any(part in SKIP_DIRS for part in path.parts):
+            continue
+        if path.name in SKIP_FILES:
+            continue
+        out.append(path)
+    return sorted(out)
+
+
+def audit() -> list[str]:
+    errors: list[str] = []
+    for path in iter_py_files():
+        rel = path.relative_to(ROOT)
+        text = path.read_text(encoding="utf-8", errors="replace")
+        for i, line in enumerate(text.splitlines(), start=1):
+            if BAD_IMPORT.search(line):
+                errors.append(f"{rel}:{i}: legacy import of package 'aider': {line.strip()}")
+            if BAD_RESOURCES.search(line):
+                errors.append(f"{rel}:{i}: use resources.files('aider_vision_core'), not __package__")
+        if path in ALLOW_TQDM:
+            continue
+        if path.name == "repomap.py":
+            continue  # uses progress_iter
+        for i, line in enumerate(text.splitlines(), start=1):
+            if BAD_TQDM.search(line) and "progress_iter" not in line:
+                errors.append(f"{rel}:{i}: use progress_iter() or gui_progress in headless paths: {line.strip()}")
+
+    repomap = PKG / "repomap.py"
+    body = repomap.read_text(encoding="utf-8")
+    if "vision_runtime" not in body or "REPO_MAP_CACHE_VERSION" not in body:
+        errors.append("repomap.py: must use vision_runtime.REPO_MAP_CACHE_VERSION and purge_legacy_tag_caches")
+
+    return errors
+
+
+def main() -> int:
+    errors = audit()
+    if errors:
+        print("audit_rename_compat FAILED:\n", file=sys.stderr)
+        for err in errors:
+            print(f"  - {err}", file=sys.stderr)
+        return 1
+    print("audit_rename_compat OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aider_vision_core-0.90.9.dev1/tests/basic/test_vision_runtime.py

@@ -0,0 +1,43 @@
+import pickle
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from aider_vision_core.vision_runtime import (
+    CACHE_LOAD_ERRORS,
+    LEGACY_PYTHON_PACKAGE,
+    REPO_MAP_CACHE_DIRNAME,
+    purge_legacy_tag_caches,
+    safe_cache_len,
+)
+
+
+class TestVisionRuntime(unittest.TestCase):
+    def test_purge_legacy_tag_caches(self):
+        root = Path(tempfile.mkdtemp())
+        try:
+            (root / ".aider.tags.cache.v3").mkdir()
+            (root / ".aider.tags.cache.v4").mkdir()
+            (root / REPO_MAP_CACHE_DIRNAME).mkdir()
+            (root / "src").mkdir()
+            removed = purge_legacy_tag_caches(root)
+            self.assertEqual(len(removed), 2)
+            self.assertFalse((root / ".aider.tags.cache.v3").exists())
+            self.assertTrue((root / REPO_MAP_CACHE_DIRNAME).exists())
+        finally:
+            shutil.rmtree(root, ignore_errors=True)
+
+    def test_safe_cache_len_on_bad_pickle(self):
+        class BadCache:
+            def __len__(self):
+                raise ModuleNotFoundError(f"No module named '{LEGACY_PYTHON_PACKAGE}'")
+
+        self.assertEqual(safe_cache_len(BadCache()), -1)
+
+    def test_cache_load_errors_includes_unpickle(self):
+        self.assertIn(pickle.UnpicklingError, CACHE_LOAD_ERRORS)
+
+
+if __name__ == "__main__":
+    unittest.main()