"""Which `uv pip check` incompatibilities the project's lock resolved on purpose. A `[tool.uv] override-dependencies` entry replaces a dependency's requirement during resolution, but the installed distribution still declares the original, so `uv pip check` reports the overridden package as incompatible. uv.lock records the overrides it applied (`[manifest] overrides`) and the version it resolved for each, so a report line is expected exactly when it names an overridden dependency installed at the locked version. Everything else still fails. Installs from the lock's requirements export (`uv pip install`) re-resolve, so they need the same overrides back (override_requirements) to reach the locked graph. Stdlib only: the bootstrap runner loads pm.environment on a system python that may predate tomllib. """ from __future__ import annotations from pathlib import Path import re # The incompatibility lines uv prints, e.g. # The package `browser-harness` requires `pillow==12.3.0`, but `13.0.0` is installed _REPORT_LINE = re.compile(r"^The package `[^`]+` requires ") _VERSION_MISMATCH = re.compile( r"^The package `[^`]+` requires `([A-Za-z0-9][A-Za-z0-9._-]*)[^`]*`, but `([^`]+)` is installed$" ) _FOUND = re.compile(r"^Found (\d+) incompatibilit(?:y|ies)$", re.MULTILINE) def _normalize(name: str) -> str: return re.sub(r"[-_.]+", "-", name).lower() def _parse_lock(text: str) -> tuple[list[dict[str, str]], list[tuple[str, str]]]: """Manifest overrides ({name, specifier?, marker?}) and (name, version) packages from uv.lock text.""" try: import tomllib except ModuleNotFoundError: manifest = re.search(r"(?ms)^\[manifest\]\s*$(.*?)(?=^\[)", text + "\n[") overrides = re.search(r"(?ms)^overrides\s*=\s*\[(.*?)^\]", manifest.group(1)) if manifest else None tables = re.findall(r"\{([^}]*)\}", overrides.group(1)) if overrides else [] entries = [dict(re.findall(r'(\w+)\s*=\s*"([^"]*)"', table)) for table in tables] packages = re.findall(r'(?m)^\[\[package\]\]\s*\nname = "([^"]+)"\s*\nversion = "([^"]+)"', text) return entries, packages data = tomllib.loads(text) entries = data.get("manifest", {}).get("overrides", []) packages = [(package["name"], package["version"]) for package in data.get("package", []) if "version" in package] return entries, packages def override_requirements(lock: Path) -> list[str]: """The lock's manifest overrides as requirement lines for `uv pip install --overrides`.""" entries, _ = _parse_lock(lock.read_text(encoding="utf-8")) lines = [] for entry in entries: if set(entry) - {"name", "specifier", "marker"}: # A source override (URL, path, git) has no requirement-line form here. raise ValueError(f"unsupported uv.lock override: {entry}") line = entry["name"] + entry.get("specifier", "") if entry.get("marker"): line += " ; " + entry["marker"] lines.append(line) return lines def overridden_versions(lock: Path) -> dict[str, set[str]]: """Locked versions of every dependency the lock's manifest overrides.""" entries, packages = _parse_lock(lock.read_text(encoding="utf-8")) overridden = {_normalize(entry["name"]) for entry in entries} versions: dict[str, set[str]] = {} for name, version in packages: if _normalize(name) in overridden: versions.setdefault(_normalize(name), set()).add(version) return versions def unexpected_incompatibilities(report: str, lock: Path | None) -> list[str] | None: """The report lines *lock* does not account for. None when the report cannot be read line by line: no lines, or uv's "Found N" total missing or different from the lines recognised (a truncated report loses its head, and any failure printed there). The caller then fails on the raw output instead of trusting a partial parse. """ lines = [line.strip() for line in report.splitlines() if _REPORT_LINE.match(line.strip())] found = _FOUND.search(report) if not lines or not found or int(found.group(1)) != len(lines): return None if lock is None or not lock.is_file(): return lines expected = overridden_versions(lock) unexpected = [] for line in lines: mismatch = _VERSION_MISMATCH.match(line) if not (mismatch and mismatch.group(2) in expected.get(_normalize(mismatch.group(1)), ())): unexpected.append(line) return unexpected