PyPatchMatch 2.0.0rc5__tar.gz → 2.0.0rc6__tar.gz

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.0rc6}/CLAUDE.md

@@ -190,7 +190,7 @@ The C++ headers double as the C++ API: `examples/cpp_example.cpp` uses `Inpainti
 
 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 `cp310-*`. Keep `csrc` free of `Python.h`,
+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.
 
@@ -284,9 +284,11 @@ ctypes releases the GIL during native calls, so inpaintings run truly concurrent
   as maximal. The distance indexes `distance2similarity`, so every metric has to clamp
   its result to that range.
 - Mask semantics: `mask` non-zero marks the holes (by default all pure white pixels,
-  computed in Python by `_default_mask`); `global_mask` marks pixels that are neither
-  filled nor used as a patch source, and whose colors must not influence the fill: the
-  downsampling kernel skips them, and gradients next to them are neutral
+  computed in Python by `_default_mask`); `_initialize_pyramid` makes them black on
+  level 0 as on the coarser levels, so their colors do not matter
+  (`test_colors_under_the_holes_do_not_matter`); `global_mask` marks pixels that are
+  neither filled nor used as a patch source, and whose colors must not influence the
+  fill: the downsampling kernel skips them, and gradients next to them are neutral
   (`test_colors_under_global_mask_do_not_matter`). At the end of `run()` every pixel
   that is not a hole, including the globally masked ones, is copied back from the input,
   so only the holes change. The tests assert this invariant (`assert_filled`,
@@ -314,8 +316,11 @@ The release wheels link a static, core-only OpenCV (`scripts/build_opencv.py`:
   is linked into the library. The wheel job checks that every wheel has the SBOM and,
   except on Windows, that `nm` finds no zlib symbol in the library. `write_sbom` fails
   if the build bundles another 3rdparty library; add a new one to the SBOM.
-- To update OpenCV, change `OPENCV_VERSION` and `OPENCV_SHA256` together. The CI cache of
-  the OpenCV build is keyed on the hash of the script.
+- To update OpenCV, change the default of `OPENCV_VERSION` and add its hash to
+  `OPENCV_SHA256S`. `PATCHMATCH_OPENCV_VERSION` selects another pinned version: the
+  CI job `opencv5` builds against OpenCV 5 (Homebrew's `opencv` since 2026), because
+  builds from the sdist link whatever OpenCV the system has. The CI cache of the
+  OpenCV build is keyed on the hash of the script.
 
 ### Packaging and versioning
 
@@ -338,8 +343,10 @@ The release wheels link a static, core-only OpenCV (`scripts/build_opencv.py`:
 ## CI
 
 - `ci.yml`: `lint` runs `pre-commit run --all-files`; `test` runs `uv run pytest` on
-  Ubuntu, macOS and Windows with Python 3.10 and 3.14, after building (or restoring) the
-  OpenCV of the build script.
+  Ubuntu, macOS and Windows with Python 3.11, 3.14 and 3.15, after building (or
+  restoring) the OpenCV of the build script. It syncs only the `test` group: the `dev`
+  group pulls in pyyaml through pre-commit, which had no wheel for 3.15 yet, and
+  `--no-build` refuses to build it.
 - pre-commit runs, besides the file checks, ruff and uv-lock: clang-format
   (`.clang-format`), shellcheck, markdownlint-cli2 (`.markdownlint.yaml`, 88 columns),
   typos (fixes in place), actionlint (checks `run:` scripts with shellcheck only if it
@@ -356,6 +363,10 @@ The release wheels link a static, core-only OpenCV (`scripts/build_opencv.py`:
 - `sanitizers` builds with `PATCHMATCH_SANITIZE=ON` on Ubuntu and runs the tests with
   the preloaded ASan runtime (see Commands). It reuses the checkout and OpenCV steps of
   `test` through YAML anchors, so change them there.
+  Scheduled (nightly) and manual runs of `ci.yml` pass `--hypothesis-profile=deep`
+  (`tests/conftest.py`: 5000 examples per property test, about 90 s locally without
+  sanitizers) and allow the job 90 minutes; a failure prints a `@reproduce_failure`
+  blob. The property tests found real bugs, so they get the most search time.
 - `coverage` builds with `PATCHMATCH_COVERAGE=ON` on Ubuntu, runs the tests and fails
   below 95 % of the C++ lines or 90 % of the branches (gcovr, see Commands).
   It reuses the same anchors. It also writes `coverage.xml` (Python) and
@@ -364,21 +375,43 @@ The release wheels link a static, core-only OpenCV (`scripts/build_opencv.py`:
   without the secret, e.g. for Dependabot and forks). Automatic analysis in SonarCloud
   is disabled; it cannot import coverage and would conflict with the CI scan. `scripts/`
   has no tests and is excluded from the coverage on new code (80 % in "Sonar way").
+  `sonar.qualitygate.wait=true` makes the scan fail on a red quality gate, so the gate
+  is part of `ci-ok` and auto-merge waits for it; the skipped scan of Dependabot and
+  fork PRs blocks nothing, unlike a required "SonarCloud Code Analysis" check, which
+  would never appear there.
 - The `uv run` steps pass `--locked` and `--no-build` (SonarCloud S8544, S8541).
   `--no-build` only forbids building dependencies from source; uv still builds the
-  project itself. The OpenCV step runs with `--only-group dev`: the project cannot be
-  built before OpenCV is installed, and `--no-project` would lock nothing.
+  project itself. The OpenCV step runs with `--only-group test`: the project cannot be
+  built before OpenCV is installed, `--no-project` would lock nothing, and the `dev`
+  group may lack wheels for the newest Python of the matrix.
+- Every setup-uv step sets `version: latest-known`: the newest uv whose checksum is
+  bundled with the pinned setup-uv. Without it, CI installs each uv release minutes
+  after publication; this way uv only moves when Dependabot updates the action, with
+  its cooldown. That uv can be a few releases older than the one of the `uv-lock` hook.
+  `prune-cache: true` keeps only wheels built from source in the uv cache; downloaded
+  wheels restore no faster than they download.
 - `system-opencv` installs `libopencv-dev` on `ubuntu-24.04` (OpenCV 4.6) instead of
   running the build script and runs the tests, because builds from the sdist link
   whatever OpenCV the system has. The runner is pinned so that the OpenCV version only
-  changes on purpose.
+  changes on purpose. The Ubuntu mirror is sometimes very slow (180 MB at under
+  300 kB/s), so the job caches the downloaded `.deb` files, keyed on the hash of
+  `apt-get install --print-uris`, with `restore-keys` for the files that did not change.
+  apt checks them against the signed index and dpkg installs them as usual. The job
+  downloads first (`--download-only`) and caches only the files of the current list.
 - `wheels.yml`: sdist, then cibuildwheel on five runners, then `sdist-fallback`;
   `publish` attests the build provenance of all files (`actions/attest`) and uploads
-  them to PyPI with trusted publishing (environment `pypi`) only for a published GitHub
-  release of `mauwii/PyPatchMatch`. The wheel jobs cache the OpenCV prefix, keyed on
-  `build_opencv.py` and `pyproject.toml` from the sdist (there is no checkout); on Linux
-  a volume makes `/tmp/opencv` of the container visible to the cache step. Runs on a
-  tag, and therefore releases, skip the cache and build OpenCV from scratch.
+  them to PyPI with trusted publishing (environment `pypi`, deployable only from tags
+  `v*`) only for a published GitHub release of `mauwii/PyPatchMatch`. It downloads the
+  artifacts named `dist-*`, so other artifacts of the run never reach PyPI. The wheel
+  jobs cache the OpenCV prefix, keyed on `build_opencv.py` and `pyproject.toml` from the
+  sdist (there is no checkout); on Linux a volume makes `/tmp/opencv` of the container
+  visible to the cache step. Runs on a tag, and therefore releases, skip the cache and
+  build OpenCV from scratch.
+  The build and test dependencies of the distributions are not locked, so the workflow
+  sets `UV_EXCLUDE_NEWER: 7 days` (the cooldown of `dependabot.yml`): `uv build` and
+  cibuildwheel's `build-frontend = "build[uv]"` resolve only releases older than a
+  week. On Linux `environment-pass` hands the variable into the container; on macOS
+  and Windows cibuildwheel uses the uv of a setup-uv step.
 - `fill-quality.yml` runs for pull requests that change `CMakeLists.txt`,
   `patchmatch/csrc` or the evaluation script: it builds the library of the base commit,
   runs `scripts/evaluate_inpainting.py --baseline` against it (patch size 3, 3 seeds),
@@ -387,15 +420,25 @@ The release wheels link a static, core-only OpenCV (`scripts/build_opencv.py`:
   so it is not in the `needs` of `ci-ok`. It repeats the OpenCV steps of `ci.yml` with
   the same cache key, because anchors do not reach across files.
 - `codeql.yml` analyzes actions, C/C++ and Python.
+- `cache-cleanup.yml` deletes the caches of a pull request when it is closed: only that
+  pull request can read them, and at the 10 GB limit GitHub evicts the least recently
+  used caches, often those of `main`. For pull requests from forks the token is
+  read-only; their caches expire after 7 days without access.
 - `ci-ok` and `wheels-ok` (re-actors/alls-green) are the required status checks; add new
-  jobs to their `needs`.
+  jobs to their `needs`. The ruleset of `main` also has a `code_scanning` rule: CodeQL
+  alerts of severity error or security severity high and above block the merge (CodeQL
+  uploads its results for Dependabot PRs too, so they are not stuck).
 - Actions are pinned to full commit SHAs with a `# vX.Y.Z` comment, and checkouts use
-  `persist-credentials: false`. Dependabot updates actions, uv and pre-commit weekly in
-  groups.
+  `persist-credentials: false`. The pre-commit hooks are pinned the same way
+  (`rev: <sha>  # frozen: vX.Y.Z`; `pre-commit autoupdate --freeze` by hand), because a
+  moved tag would otherwise reach CI and fresh clones without review. Dependabot
+  updates actions, uv and pre-commit weekly in groups, SHA and comment together. The
+  repository is a GitHub fork, on which Dependabot version updates are off by default;
+  they are enabled in Insights → Dependency graph → Dependabot.
 
 ## Conventions
 
-- Python >= 3.10: keep `from __future__ import annotations`. Ruff targets py310 with the
+- 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_`

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0rc5
+Version: 2.0.0rc6
 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
@@ -78,12 +78,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.0rc6}/README.md

@@ -48,12 +48,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.0rc6/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.0rc6}/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.0rc6'
+__version_tuple__ = version_tuple = (2, 0, 0, 'rc6')
 
-__commit_id__ = commit_id = 'g3dcd7aa74'
+__commit_id__ = commit_id = 'g7cfa5cb5b'

{pypatchmatch-2.0.0rc5 → pypatchmatch-2.0.0rc6}/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.0rc6}/pyproject.toml

@@ -15,7 +15,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,16 +24,16 @@ 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"]
+dependencies = ["numpy>=1.23.2", "pillow>=9.2.0"]
 dynamic = ["version"]
 
 [project.urls]
@@ -78,10 +78,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 +92,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 +112,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 +142,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.0rc6}/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, which CI tests because
+builds from the sdist link whatever OpenCV the system has.
 """
 
 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 "4.14.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",
@@ -155,8 +165,7 @@ def main() -> None:
         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:

pypatchmatch-2.0.0rc6/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)

pypatchmatch-2.0.0rc6/tests/test_properties.py

@@ -0,0 +1,159 @@
+"""Property-based tests: the invariants of the inpainting on random inputs."""
+
+import numpy as np
+from hypothesis import given, settings
+from hypothesis import strategies as st
+from hypothesis.extra import numpy as hnp
+
+import patchmatch
+
+sizes = st.integers(1, 24)
+patch_sizes = st.integers(1, 4)
+
+
+@st.composite
+def images_and_masks(draw):
+    """An image, a hole mask (None: the white pixels) and an optional global mask."""
+    shape = (draw(sizes), draw(sizes))
+    image = draw(hnp.arrays(np.uint8, (*shape, 3)))
+    mask = draw(st.none() | hnp.arrays(np.bool_, shape))
+    global_mask = draw(st.none() | hnp.arrays(np.bool_, shape))
+    return image, mask, global_mask
+
+
+def white_pixels(image):
+    return (image == 255).all(axis=-1)
+
+
+def assert_only_holes_changed(result, image, mask, global_mask):
+    assert result.shape == image.shape
+    assert result.dtype == np.uint8
+    holes = white_pixels(image) if mask is None else mask
+    if global_mask is not None:
+        holes = holes & ~global_mask
+    np.testing.assert_array_equal(result[~holes], image[~holes])
+
+
+def fills(image, mask, ijmap, **kwargs):
+    """The results of inpaint and inpaint_regularity with the same seed."""
+    patchmatch.set_random_seed(0)
+    return (
+        patchmatch.inpaint(image, mask, **kwargs),
+        patchmatch.inpaint_regularity(image, mask, ijmap, **kwargs),
+    )
+
+
+def assert_same_fills(actual, expected):
+    for result, reference in zip(actual, expected, strict=True):
+        np.testing.assert_array_equal(result, reference)
+
+
+@settings(deadline=None)
+@given(images_and_masks(), patch_sizes)
+def test_inpaint(inputs, patch_size):
+    image, mask, global_mask = inputs
+
+    def inpaint():
+        patchmatch.set_random_seed(0)
+        return patchmatch.inpaint(
+            image, mask, global_mask=global_mask, patch_size=patch_size
+        )
+
+    result = inpaint()
+    assert_only_holes_changed(result, image, mask, global_mask)
+    np.testing.assert_array_equal(inpaint(), result)
+
+
+@settings(deadline=None)
+@given(
+    images_and_masks(),
+    patch_sizes,
+    hnp.arrays(
+        np.float32,
+        st.tuples(sizes, sizes, st.just(3)),
+        elements=st.floats(-2, 2, width=32),
+    ),
+    st.floats(0, 10),
+)
+def test_inpaint_regularity(inputs, patch_size, ijmap, guide_weight):
+    image, mask, global_mask = inputs
+    result = patchmatch.inpaint_regularity(
+        image,
+        mask,
+        ijmap,
+        global_mask=global_mask,
+        patch_size=patch_size,
+        guide_weight=guide_weight,
+    )
+    assert_only_holes_changed(result, image, mask, global_mask)
+
+
+@settings(deadline=None)
+@given(images_and_masks(), hnp.arrays(np.uint8, (24, 24, 3)), patch_sizes)
+def test_colors_under_global_mask_do_not_matter(inputs, colors, patch_size):
+    image, mask, global_mask = inputs
+    if global_mask is None:
+        global_mask = np.zeros(image.shape[:2], dtype=bool)
+    if mask is None:
+        mask = white_pixels(image)
+    colors = colors[: image.shape[0], : image.shape[1]]
+    recolored = np.where(global_mask[..., None], colors, image)
+    ijmap = image.astype(np.float32) / 255
+    kwargs = {"global_mask": global_mask, "patch_size": patch_size}
+
+    holes = mask & ~global_mask
+    actual = fills(recolored, mask, ijmap, **kwargs)
+    expected = fills(image, mask, ijmap, **kwargs)
+    for result, reference in zip(actual, expected, strict=True):
+        np.testing.assert_array_equal(result[holes], reference[holes])
+
+
+@settings(deadline=None)
+@given(images_and_masks(), hnp.arrays(np.uint8, (24, 24, 3)), patch_sizes)
+def test_colors_under_the_holes_do_not_matter(inputs, colors, patch_size):
+    image, mask, global_mask = inputs
+    if mask is None:
+        mask = white_pixels(image)
+    holes = mask if global_mask is None else mask & ~global_mask
+    colors = colors[: image.shape[0], : image.shape[1]]
+    recolored = np.where(holes[..., None], colors, image)
+    ijmap = image.astype(np.float32) / 255
+    kwargs = {"global_mask": global_mask, "patch_size": patch_size}
+
+    assert_same_fills(
+        fills(recolored, mask, ijmap, **kwargs), fills(image, mask, ijmap, **kwargs)
+    )
+
+
+@settings(deadline=None)
+@given(images_and_masks(), patch_sizes)
+def test_empty_global_mask_changes_nothing(inputs, patch_size):
+    image, mask, _ = inputs
+    ijmap = image.astype(np.float32) / 255
+    empty = np.zeros(image.shape[:2], dtype=bool)
+
+    assert_same_fills(
+        fills(image, mask, ijmap, global_mask=empty, patch_size=patch_size),
+        fills(image, mask, ijmap, patch_size=patch_size),
+    )
+
+
+@settings(deadline=None)
+@given(images_and_masks(), hnp.arrays(np.uint8, (24, 24)), patch_sizes)
+def test_only_the_holes_of_the_mask_matter(inputs, values, patch_size):
+    """Any non-zero value marks a hole, and globally masked pixels are none."""
+    image, mask, global_mask = inputs
+    if global_mask is None:
+        global_mask = np.zeros(image.shape[:2], dtype=bool)
+    holes = white_pixels(image) if mask is None else mask
+    holes = holes & ~global_mask
+    values = values[: image.shape[0], : image.shape[1]]
+    # any value under the global mask, a non-zero one in the holes, else zero
+    other_mask = np.where(global_mask, values, np.where(holes, values | 1, 0))
+    ijmap = image.astype(np.float32) / 255
+    kwargs = {"global_mask": global_mask, "patch_size": patch_size}
+
+    assert_same_fills(
+        fills(image, other_mask, ijmap, **kwargs),
+        fills(image, mask, ijmap, **kwargs),
+    )

pypatchmatch-2.0.0rc5/tests/test_properties.py

@@ -1,95 +0,0 @@
-"""Property-based tests: the invariants of the inpainting on random inputs."""
-
-import numpy as np
-from hypothesis import given, settings
-from hypothesis import strategies as st
-from hypothesis.extra import numpy as hnp
-
-import patchmatch
-
-sizes = st.integers(1, 24)
-patch_sizes = st.integers(1, 4)
-
-
-@st.composite
-def images_and_masks(draw):
-    """An image, a hole mask (None: the white pixels) and an optional global mask."""
-    shape = (draw(sizes), draw(sizes))
-    image = draw(hnp.arrays(np.uint8, (*shape, 3)))
-    mask = draw(st.none() | hnp.arrays(np.bool_, shape))
-    global_mask = draw(st.none() | hnp.arrays(np.bool_, shape))
-    return image, mask, global_mask
-
-
-def assert_only_holes_changed(result, image, mask, global_mask):
-    assert result.shape == image.shape
-    assert result.dtype == np.uint8
-    holes = (image == 255).all(axis=-1) if mask is None else mask
-    if global_mask is not None:
-        holes = holes & ~global_mask
-    np.testing.assert_array_equal(result[~holes], image[~holes])
-
-
-@settings(deadline=None)
-@given(images_and_masks(), patch_sizes)
-def test_inpaint(inputs, patch_size):
-    image, mask, global_mask = inputs
-
-    def inpaint():
-        patchmatch.set_random_seed(0)
-        return patchmatch.inpaint(
-            image, mask, global_mask=global_mask, patch_size=patch_size
-        )
-
-    result = inpaint()
-    assert_only_holes_changed(result, image, mask, global_mask)
-    np.testing.assert_array_equal(inpaint(), result)
-
-
-@settings(deadline=None)
-@given(
-    images_and_masks(),
-    patch_sizes,
-    hnp.arrays(
-        np.float32,
-        st.tuples(sizes, sizes, st.just(3)),
-        elements=st.floats(-2, 2, width=32),
-    ),
-    st.floats(0, 10),
-)
-def test_inpaint_regularity(inputs, patch_size, ijmap, guide_weight):
-    image, mask, global_mask = inputs
-    result = patchmatch.inpaint_regularity(
-        image,
-        mask,
-        ijmap,
-        global_mask=global_mask,
-        patch_size=patch_size,
-        guide_weight=guide_weight,
-    )
-    assert_only_holes_changed(result, image, mask, global_mask)
-
-
-@settings(deadline=None)
-@given(images_and_masks(), hnp.arrays(np.uint8, (24, 24, 3)), patch_sizes)
-def test_colors_under_global_mask_do_not_matter(inputs, colors, patch_size):
-    image, mask, global_mask = inputs
-    if global_mask is None:
-        global_mask = np.zeros(image.shape[:2], dtype=bool)
-    if mask is None:
-        mask = (image == 255).all(axis=-1)
-    colors = colors[: image.shape[0], : image.shape[1]]
-    recolored = np.where(global_mask[..., None], colors, image)
-    ijmap = image.astype(np.float32) / 255
-
-    def fills(source):
-        patchmatch.set_random_seed(0)
-        kwargs = {"global_mask": global_mask, "patch_size": patch_size}
-        return (
-            patchmatch.inpaint(source, mask, **kwargs),
-            patchmatch.inpaint_regularity(source, mask, ijmap, **kwargs),
-        )
-
-    holes = mask & ~global_mask
-    for result, expected in zip(fills(recolored), fills(image), strict=True):
-        np.testing.assert_array_equal(result[holes], expected[holes])