PyPatchMatch 2.0.0rc5__tar.gz → 2.0.1__tar.gz

pypatchmatch-2.0.1/CLAUDE.md

@@ -0,0 +1,155 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in
+this repository. The details of the native code, the C interface, packaging and CI are
+path-scoped rules in `.claude/rules/`, which load when a matching file is read or
+edited; read the rule before changing such a file through Bash. The sanitizer, C++
+coverage and fill-quality runs are skills in `.claude/skills/`.
+
+## Project
+
+PyPatchMatch implements PatchMatch based image inpainting (Barnes et al., SIGGRAPH 2009):
+a C++17 library on top of OpenCV core, and a thin Python package that loads it through
+`ctypes`. It is published on PyPI as `PyPatchMatch` (import name `patchmatch`) and used
+by InvokeAI. This repository (`mauwii/PyPatchMatch`) is the maintained fork of
+`invoke-ai/PyPatchMatch`, which derives from `vacancy/PyPatchMatch` and
+`younesse-cv/PatchMatch`.
+
+## Commands
+
+The project is managed with uv (`.python-version` pins 3.12 for the local venv). Building
+needs a C++17 compiler, CMake >= 3.21 and an OpenCV that `find_package(OpenCV)` finds:
+Homebrew `opencv`, `libopencv-dev`, or an installation prefix in `OpenCV_ROOT`.
+
+```sh
+uv sync                                    # .venv, editable install, compiles the library
+uv run pre-commit install
+uv run pytest                              # all tests, with the coverage gate
+uv run pytest -m "not e2e"                 # fast unit tests only
+uv run pytest -m e2e --no-cov              # end-to-end tests only
+uv run pytest tests/test_patch_match.py::test_inpaint_global_mask --no-cov
+uv run pytest -k regularity --no-cov
+uv run mypy                                # strict, also a pre-commit hook
+uv run pre-commit run --all-files          # what the CI lint job runs
+uv run ruff check --fix . && uv run ruff format .
+uv build                                   # sdist and wheel into dist/
+```
+
+- Pass `--no-cov` for any partial run: `addopts` always enables coverage, and
+  `fail_under = 95` (branch coverage, subprocesses included through
+  `patch = ["subprocess"]`) fails the run otherwise.
+- Use `uv run pytest`, not `python -m pytest`. The latter puts the repository root on
+  `sys.path`, which imports the source tree `patchmatch/` without the compiled library;
+  the symptoms are the warning `patchmatch failed to load: libpatchmatch.* not found`
+  and `RuntimeError: the patchmatch native library is not available` in every test.
+- `--cov=patchmatch` measures the source tree, so coverage only works with the editable
+  install that `uv sync` creates. With a non-editable install (`uv sync --no-editable`,
+  `uv pip install .`) it reports 0 % and the gate fails.
+- `uv sync` rebuilds the library only when a `tool.uv.cache-keys` entry changes
+  (`CMakeLists.txt`, `patchmatch/csrc/*`, `pyproject.toml`, git commit or tags). Force it
+  with `uv sync --reinstall-package pypatchmatch`.
+- CI builds the library with warnings as errors. Locally:
+  `SKBUILD_CMAKE_DEFINE=CMAKE_COMPILE_WARNING_AS_ERROR=ON uv sync --reinstall-package pypatchmatch`.
+
+Build against the same static, core-only OpenCV as the release wheels:
+
+```sh
+export OpenCV_ROOT=/tmp/opencv
+uv run --no-project python scripts/build_opencv.py   # pinned version and SHA-256
+uv sync --reinstall-package pypatchmatch
+```
+
+Other entry points:
+
+- `examples/cpp_example_run.sh` builds the library and `examples/cpp_example.cpp` with
+  CMake into `build/cpp` and runs it. It needs OpenCV `imgcodecs`, so a full OpenCV, not
+  the core-only build of the script.
+- `uv run python examples/py_example.py` (and `py_example_global_mask.py`) write
+  `examples/images/forest_recovered.bmp`, which is git-ignored.
+- `uv run python scripts/render_readme_example.py` runs `py_example.py` and renders the
+  picture at the top of the README, `examples/images/readme_example.jpg`; rerun it and
+  commit the picture after changes that affect the fills.
+- CMake options: `PATCHMATCH_BUILD_EXAMPLES` (OFF), `PATCHMATCH_FAST_MATH` (ON,
+  `-ffast-math` or `/fp:fast`), `PATCHMATCH_SANITIZE` (OFF, ASan and UBSan with
+  `float-cast-overflow`, every finding aborts; turns off fast math, which lets the
+  compiler drop checks; GCC and Clang only), `PATCHMATCH_COVERAGE` (OFF, gcov counters
+  at `-Og`; GCC and Clang only).
+
+## Architecture
+
+### Layers, in the call order of `patchmatch.inpaint`
+
+1. `patchmatch/__init__.py` re-exports the public API of `patch_match.py` and
+   `__version__` from the generated `_version.py`. `test_top_level_exports` checks that
+   every name in `patch_match.__all__` is re-exported.
+2. `patchmatch/patch_match.py` is the public API. It validates and canonicalizes the
+   inputs (`_prepare_inputs`, `_check_patch_size`, the `ijmap` and `guide_weight`
+   checks), picks the entry point (`PM_inpaint`, `PM_inpaint2` with a global mask, and
+   their `_regularity` variants) and runs it through `_call`. It loads the library at
+   import time; on `OSError` it logs a warning and sets `patchmatch_available = False`,
+   and every function then raises `RuntimeError` through `_get_lib()`.
+3. `patchmatch/_lib.py` is the ctypes layer: the `CShapeT`/`CMatT` structures, the dtype
+   table, `np_to_pymat`/`pymat_to_np`, `find_library` (looks for `libpatchmatch.so`,
+   `libpatchmatch.dylib` or `patchmatch.dll` in every directory of `patchmatch.__path__`)
+   and `load_library` (argtypes and restype of every `PM_*` function).
+4. `patchmatch/csrc/pyinterface.{h,cpp}` is the `extern "C"` API: the `PM_*` functions,
+   the conversion between `PM_mat_t` and `cv::Mat`, the global settings and the error
+   reporting.
+5. `csrc/inpaint.{h,cpp}`: `Inpainting`, the image pyramid and the EM loop.
+6. `csrc/nnf.{h,cpp}`: `NearestNeighborField` (propagation and random search) and the
+   distance metrics `PatchSSDDistanceMetric` and `RegularityGuidedPatchDistanceMetricV2`.
+7. `csrc/masked_image.{h,cpp}`: `MaskedImage`, an image with its hole mask and optional
+   global mask, down- and upsampling, gradients.
+
+The C++ headers double as the C++ API: `examples/cpp_example.cpp` uses `Inpainting` and
+`PatchSSDDistanceMetric` directly.
+
+### ctypes instead of a CPython extension
+
+The library does not use the CPython ABI, so the wheels are tagged
+`py3-none-<platform>` (`wheel.py-api = "py3"`): one wheel per platform serves all Python
+versions, and cibuildwheel only builds `cp311-*`. Keep `csrc` free of `Python.h`,
+pybind11 or nanobind. The C++ sources are excluded from the wheel (`wheel.exclude`);
+CMake installs the shared library into the package directory.
+
+## Conventions
+
+- Python >= 3.11: keep `from __future__ import annotations`. Ruff targets py311 with the
+  rules B, C4, E, F, I, RUF, SIM, UP and W, and formats at 88 columns. `patchmatch/csrc`
+  is excluded from ruff. C++ is formatted by clang-format (Microsoft style, 120 columns,
+  includes grouped as own header, `<...>`, `"..."`); naming is not checked: `m_`
+  members, `k` constants. Commit a reformat separately and add its hash to
+  `.git-blame-ignore-revs`.
+- The package ships `py.typed`; public functions are fully annotated. mypy checks
+  `patchmatch` and `tests` in strict mode (`[tool.mypy]`); the tests have to use the
+  API correctly but need no annotations of their own. A deliberately wrong argument
+  goes through a test parameter instead of a `# type: ignore`.
+- Backwards compatibility: `from patchmatch import patch_match` and
+  `patch_match.CShapeT`/`CMatT` keep working (tested).
+- Comments explain why: which crash a check prevents, why a construct is avoided.
+- No `NOSONAR` markers: change the code so that the SonarCloud rule is satisfied, and ask
+  when that seems impossible. The only exception is `nnf.cpp`: cpp:S2245 flags every
+  declaration of `std::mt19937`, which only drives the randomized search.
+- Tests check invariants instead of golden images: holes filled, all other pixels
+  unchanged, determinism with `set_random_seed`, fills that blend in with their
+  surroundings. `test_patch_match.py` and `test_e2e.py` seed through an autouse fixture.
+  Unit tests use a small synthetic image; the `e2e` tests use
+  `examples/images/forest_pruned.bmp` and mirror the workflows of the README and the
+  examples. `test_properties.py` checks the invariants on random inputs with Hypothesis
+  (in the `test` group, so the wheel tests run it too); it seeds inside the tests,
+  because Hypothesis rejects function-scoped fixtures, and has no deadline, because
+  the sanitizer and coverage builds are much slower.
+- The README documents the behavior (mask semantics, `patch_size` as a radius, the
+  fallback installation); update it together with API or installation changes.
+- Commit messages: imperative subject in sentence case without a prefix (e.g. "Reject
+  invalid patch sizes and empty regularity maps"), and a body that explains the reason,
+  with measurements where relevant. Changes go through PRs from branches such as
+  `fix/<topic>`.
+
+## Git and GitHub
+
+- `origin` is `mauwii/PyPatchMatch`, where PRs and releases go; `upstream` is
+  `invoke-ai/PyPatchMatch`. `gh` resolves the default repository to upstream, so pass
+  `-R mauwii/PyPatchMatch`.
+- Releases: creating a GitHub release with a tag like `v2.0.0` (or `v2.0.0rc2` for
+  pre-releases) builds the wheels and publishes them to PyPI.

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0rc5
+Version: 2.0.1
 Summary: This library implements the PatchMatch based inpainting algorithm.
 Keywords: inpainting,patchmatch,image-processing,opencv
 Author-Email: The InvokeAI Project <lincoln.stein@gmail.com>, Jiayuan Mao <maojiayuan@gmail.com>, Kyle Schouviller <kyle0654@hotmail.com>, Matthias Wild <mauwii@outlook.de>, Younesse ANDAM <younesse.andam@gmail.com>
@@ -12,20 +12,20 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Multimedia :: Graphics
 Classifier: Topic :: Scientific/Engineering :: Image Processing
 Classifier: Typing :: Typed
 Project-URL: Source Code, https://github.com/mauwii/PyPatchMatch
 Project-URL: Issues, https://github.com/mauwii/PyPatchMatch/issues
 Project-URL: Release Notes, https://github.com/mauwii/PyPatchMatch/releases
-Requires-Python: >=3.10
-Requires-Dist: numpy>=1.21.6
-Requires-Dist: pillow>=8.4.0
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.23.2
+Requires-Dist: pillow>=9.2.0
 Description-Content-Type: text/markdown
 
 # PatchMatch based Inpainting
@@ -42,6 +42,12 @@ and Python interfaces. This implementation is heavily based on the implementatio
 Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
 with some bug fixes, and updates.
 
+![Birdhouses removed from a photo by patchmatch.inpaint](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v2.0.1/examples/images/readme_example.jpg)
+
+From left to right: the photo, the input of
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)
+with the birdhouses painted out in white, and its result.
+
 ## Installation
 
 ```sh
@@ -78,12 +84,13 @@ result = patchmatch.inpaint(image, mask, patch_size=3)
 
 The mask must have the same height and width as the image. If `mask` is omitted, all
 pure white pixels are treated as holes. Only the holes are filled; all other pixels keep
-their values. Holes need hard edges: an anti-aliased brush leaves light pixels along
-the edge of its strokes that are not pure white, so they count as known and the fill
-continues them. Paint without anti-aliasing or pass a mask that covers those pixels as
-well. The optional keyword argument `global_mask`, in the same format, marks
-pixels that are neither filled nor used as a source; they keep their values as well, and
-their colors have no influence on the fill (see
+their values, and the colors under the holes have no influence on the fill. Holes need
+hard edges: an anti-aliased brush leaves light pixels along the edge of its strokes that
+are not pure white, so they count as known and the fill continues them. Paint without
+anti-aliasing or pass a mask that covers those pixels as well. The optional keyword
+argument `global_mask`, in the same format, marks pixels that are neither filled nor
+used as a source; they keep their values as well, and their colors have no influence on
+the fill (see
 [examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
 `patchmatch.patchmatch_available` tells whether the native library could be loaded.
 The previous import path `from patchmatch import patch_match` keeps working.

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/README.md

@@ -12,6 +12,12 @@ and Python interfaces. This implementation is heavily based on the implementatio
 Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
 with some bug fixes, and updates.
 
+![Birdhouses removed from a photo by patchmatch.inpaint](examples/images/readme_example.jpg)
+
+From left to right: the photo, the input of
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)
+with the birdhouses painted out in white, and its result.
+
 ## Installation
 
 ```sh
@@ -48,12 +54,13 @@ result = patchmatch.inpaint(image, mask, patch_size=3)
 
 The mask must have the same height and width as the image. If `mask` is omitted, all
 pure white pixels are treated as holes. Only the holes are filled; all other pixels keep
-their values. Holes need hard edges: an anti-aliased brush leaves light pixels along
-the edge of its strokes that are not pure white, so they count as known and the fill
-continues them. Paint without anti-aliasing or pass a mask that covers those pixels as
-well. The optional keyword argument `global_mask`, in the same format, marks
-pixels that are neither filled nor used as a source; they keep their values as well, and
-their colors have no influence on the fill (see
+their values, and the colors under the holes have no influence on the fill. Holes need
+hard edges: an anti-aliased brush leaves light pixels along the edge of its strokes that
+are not pure white, so they count as known and the fill continues them. Paint without
+anti-aliasing or pass a mask that covers those pixels as well. The optional keyword
+argument `global_mask`, in the same format, marks pixels that are neither filled nor
+used as a source; they keep their values as well, and their colors have no influence on
+the fill (see
 [examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
 `patchmatch.patchmatch_available` tells whether the native library could be loaded.
 The previous import path `from patchmatch import patch_match` keeps working.

pypatchmatch-2.0.1/SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Supported Versions
+
+Security fixes are released as a new version of PyPatchMatch on PyPI. Only the latest
+release is supported; older versions are not updated.
+
+## Reporting a Vulnerability
+
+Please report vulnerabilities privately through GitHub's
+[vulnerability reporting](https://github.com/mauwii/PyPatchMatch/security/advisories/new),
+not in a public issue.
+
+## OpenCV
+
+The wheels on PyPI contain a statically linked, core-only build of OpenCV; its version
+is listed in the CycloneDX SBOM in `sboms/opencv.cdx.json` of each wheel's
+`.dist-info`. A vulnerability in OpenCV core is fixed by a new PyPatchMatch release
+with an updated OpenCV. Installations built from the source distribution link the
+OpenCV of the system and get its fixes from there.

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/patchmatch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.0rc5'
-__version_tuple__ = version_tuple = (2, 0, 0, 'rc5')
+__version__ = version = '2.0.1'
+__version_tuple__ = version_tuple = (2, 0, 1)
 
-__commit_id__ = commit_id = 'g3dcd7aa74'
+__commit_id__ = commit_id = 'g995b76749'

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/patchmatch/csrc/inpaint.cpp

@@ -164,7 +164,18 @@ Inpainting::Inpainting(
 
 void Inpainting::_initialize_pyramid()
 {
-    auto source = m_initial;
+    // The colors under the holes would reach the fill through the gradients of their
+    // neighbors and the target of a single-level pyramid. Black, like on coarser levels.
+    auto source = m_initial.clone();
+    const auto size = source.size();
+    for (int y = 0; y < size.height; ++y)
+    {
+        for (int x = 0; x < size.width; ++x)
+        {
+            if (source.is_masked(y, x))
+                std::fill_n(source.get_mutable_image(y, x), 3, 0);
+        }
+    }
     m_pyramid.push_back(source);
     while (source.size().height > m_distance_metric->patch_size() &&
            source.size().width > m_distance_metric->patch_size())

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/pyproject.toml

@@ -1,11 +1,10 @@
 [build-system]
 build-backend = "scikit_build_core.build"
-requires = ["scikit-build-core>=0.11", "setuptools-scm>=8"]
+requires = ["scikit-build-core>=0.11.2", "setuptools-scm>=8"]
 
 [project]
 name = "PyPatchMatch"
 description = "This library implements the PatchMatch based inpainting algorithm."
-readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
@@ -15,7 +14,7 @@ authors = [
     { name = "Matthias Wild", email = "mauwii@outlook.de" },
     { name = "Younesse ANDAM", email = "younesse.andam@gmail.com" },
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 keywords = ["inpainting", "patchmatch", "image-processing", "opencv"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -24,17 +23,17 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Programming Language :: C++",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Multimedia :: Graphics",
     "Topic :: Scientific/Engineering :: Image Processing",
     "Typing :: Typed",
 ]
-dependencies = ["numpy>=1.21.6", "pillow>=8.4.0"]
-dynamic = ["version"]
+dependencies = ["numpy>=1.23.2", "pillow>=9.2.0"]
+dynamic = ["version", "readme"]
 
 [project.urls]
 "Source Code" = "https://github.com/mauwii/PyPatchMatch"
@@ -56,6 +55,7 @@ wheel.py-api = "py3"
 wheel.packages = ["patchmatch"]
 wheel.exclude = ["patchmatch/csrc/**"]
 metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
+metadata.readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
 # The release wheels are built from the sdist, so it has to contain the tests
 # and their input image; _version.py is generated and therefore git-ignored.
 sdist.include = ["examples/images/forest_pruned.bmp", "patchmatch/_version.py"]
@@ -70,6 +70,17 @@ if.from-sdist = true
 if.failed = true
 wheel.cmake = false
 
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+
+# PyPI does not resolve relative image paths
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
+pattern = '!\[([^\]]*)\]\((?!https?:)([^)]+)\)'
+replacement = '![\1](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v$HFPR_VERSION/\2)'
+
 [tool.setuptools_scm]
 version_file = "patchmatch/_version.py"
 # used when building without git metadata, e.g. from a GitHub source archive
@@ -78,10 +89,13 @@ fallback_version = "0.0.0"
 [tool.cibuildwheel]
 # The wheels are Python-version independent (py3-none-<platform>), so each platform
 # is built and tested once; the CI workflow covers the other Python versions.
-build = "cp310-*"
+build = "cp311-*"
 skip = "*-musllinux_*"
 # OpenCV is built once per job in before-all, only for the runner's native arch
 archs = ["native"]
+# uv installs the build and test environments, so that UV_EXCLUDE_NEWER of wheels.yml
+# applies to them
+build-frontend = "build[uv]"
 test-groups = ["test"]
 test-command = "pytest {project}/tests --no-cov"
 before-all = "python {project}/scripts/build_opencv.py"
@@ -89,6 +103,7 @@ environment = { OpenCV_ROOT = "/tmp/opencv" }
 
 [tool.cibuildwheel.linux]
 before-all = "/opt/python/cp312-cp312/bin/python {project}/scripts/build_opencv.py"
+environment-pass = ["UV_EXCLUDE_NEWER"]
 
 [tool.cibuildwheel.macos]
 environment = { OpenCV_ROOT = "/tmp/opencv", MACOSX_DEPLOYMENT_TARGET = "11.0" }
@@ -108,7 +123,7 @@ cache-keys = [
 [tool.ruff]
 extend-exclude = ["patchmatch/csrc"]
 line-length = 88
-target-version = "py310"
+target-version = "py311"
 
 [tool.ruff.lint]
 select = ["B", "C4", "E", "F", "I", "RUF", "SIM", "UP", "W"]
@@ -138,7 +153,10 @@ warn_return_any = false
 
 [tool.pytest.ini_options]
 addopts = ["--cov-branch", "--cov-report=term:skip-covered", "--cov=patchmatch"]
+# shows which test hangs before the job timeout kills the run
+faulthandler_timeout = 300
 markers = ["e2e: end-to-end tests of the user workflows (deselect with -m 'not e2e')"]
-minversion = "6.0"
+minversion = "9.0"
 python_files = ["test_*.py"]
+strict = true
 testpaths = ["tests"]

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.1}/scripts/build_opencv.py

@@ -4,6 +4,9 @@ The patchmatch library only needs opencv_core. Linking it statically keeps the
 wheels small and free of OpenCV's GUI/codec dependencies.
 
 Usage: python build_opencv.py  (installs into $OpenCV_ROOT)
+
+PATCHMATCH_OPENCV_VERSION selects another pinned version, e.g. 4.14.0 to rebuild the
+wheels of PyPatchMatch 2.0.0.
 """
 
 import hashlib
@@ -17,13 +20,20 @@ import tempfile
 import urllib.request
 from pathlib import Path
 
-OPENCV_VERSION = "4.14.0"
+# The wheels link this code statically, so every archive is pinned by its SHA-256,
+# e.g. from `sha256sum` or `shasum -a 256`.
+OPENCV_SHA256S = {
+    "4.14.0": "ee8fb9b30eb60850431b4656447080e3737b56e45719c92b67f245950609f86e",
+    "5.0.0": "b0528f5a1d379d59d4701cb28c36e22214cc51cf64594e5b56f2d3e6c0233095",
+}
+# the version of the release wheels
+OPENCV_VERSION = os.environ.get("PATCHMATCH_OPENCV_VERSION") or "5.0.0"
+if OPENCV_VERSION not in OPENCV_SHA256S:
+    sys.exit(f"OpenCV {OPENCV_VERSION} is not pinned, known: {sorted(OPENCV_SHA256S)}")
+OPENCV_SHA256 = OPENCV_SHA256S[OPENCV_VERSION]
 OPENCV_URL = (
     f"https://github.com/opencv/opencv/archive/refs/tags/{OPENCV_VERSION}.tar.gz"
 )
-# The wheels link this code statically, so the archive is pinned by its SHA-256.
-# Update it together with the version, e.g. with `sha256sum` or `shasum -a 256`.
-OPENCV_SHA256 = "ee8fb9b30eb60850431b4656447080e3737b56e45719c92b67f245950609f86e"
 
 CMAKE_OPTIONS = {
     "CMAKE_BUILD_TYPE": "Release",
@@ -63,6 +73,8 @@ CMAKE_OPTIONS = {
     "WITH_QT": "OFF",
     "WITH_TIFF": "OFF",
     "WITH_V4L": "OFF",
+    # an installed VTK adds OpenGL to the link interface of core (OpenCV 5)
+    "WITH_VTK": "OFF",
     "WITH_WEBP": "OFF",
     "WITH_IPP": "OFF",
     "WITH_ITT": "OFF",
@@ -80,6 +92,8 @@ WINDOWS_CMAKE_OPTIONS = {
     "OPENCV_CONFIG_INSTALL_PATH": "cmake",
     "OPENCV_INSTALL_BINARIES_PREFIX": "",
     "OPENCV_SKIP_CMAKE_ROOT_CONFIG": "ON",
+    # skips OpenCV 5's assembler check: MinGW's would set MINGW and link pthread
+    "CMAKE_ASM_COMPILER": "CMAKE_ASM_COMPILER-NOTFOUND",
 }
 
 
@@ -149,21 +163,22 @@ def main() -> None:
         return
 
     cmake = find_cmake()
-    with tempfile.TemporaryDirectory() as tmp:
-        archive = Path(tmp) / "opencv.tar.gz"
+    with tempfile.TemporaryDirectory() as tmp_name:
+        # OpenCV 5 compares paths as strings, which fails with 8.3 names (RUNNER~1)
+        tmp = Path(tmp_name).resolve()
+        archive = tmp / "opencv.tar.gz"
         print(f"Downloading {OPENCV_URL}", flush=True)
         urllib.request.urlretrieve(OPENCV_URL, archive)
         verify_archive(archive)
         with tarfile.open(archive) as tar:
-            # extraction filters are missing on older patch releases, e.g. the
-            # last Windows installer of Python 3.10 (3.10.11)
+            # extraction filters are missing on older patch releases (3.11 < 3.11.4)
             if hasattr(tarfile, "data_filter"):
                 tar.extractall(tmp, filter="data")
             else:
                 tar.extractall(tmp)
 
-        source = Path(tmp) / f"opencv-{OPENCV_VERSION}"
-        build = Path(tmp) / "build"
+        source = tmp / f"opencv-{OPENCV_VERSION}"
+        build = tmp / "build"
         options = {**CMAKE_OPTIONS, "CMAKE_INSTALL_PREFIX": prefix.as_posix()}
         if sys.platform == "win32":
             options.update(WINDOWS_CMAKE_OPTIONS)

pypatchmatch-2.0.1/scripts/render_readme_example.py

@@ -0,0 +1,36 @@
+"""Render examples/images/readme_example.jpg, the picture at the top of the README.
+
+It runs examples/py_example.py and shows, from left to right, the photo forest.bmp,
+the input forest_pruned.bmp with the birdhouses painted out in white, and the result.
+The PyPI description links the picture at the release tag, so rerun the script and
+commit the picture after changes that affect the fills.
+
+Usage:
+    uv run python scripts/render_readme_example.py
+"""
+
+from __future__ import annotations
+
+import runpy
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+import patchmatch
+
+EXAMPLES = Path(__file__).resolve().parents[1] / "examples"
+IMAGES = EXAMPLES / "images"
+
+if __name__ == "__main__":
+    patchmatch.set_random_seed(0)
+    runpy.run_path(str(EXAMPLES / "py_example.py"), run_name="__main__")
+    panels = [
+        np.asarray(Image.open(IMAGES / f"forest{suffix}.bmp"))
+        for suffix in ("", "_pruned", "_recovered")
+    ]
+    gap = np.full((panels[0].shape[0], 8, 3), 255, dtype=np.uint8)
+    picture = np.hstack([panels[0], gap, panels[1], gap, panels[2]])
+    Image.fromarray(picture).save(
+        IMAGES / "readme_example.jpg", quality=85, optimize=True
+    )

pypatchmatch-2.0.1/tests/conftest.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from hypothesis import settings
+
+# weekly CI; print_blob shows how to reproduce a failure locally
+settings.register_profile("deep", max_examples=5000, print_blob=True)