PyPatchMatch 2.1.0__tar.gz → 2.2.0b3__tar.gz

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/CLAUDE.md

@@ -1,10 +1,9 @@
 # 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/`.
+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
 
@@ -27,24 +26,18 @@ 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.
+- Keep the editable install that `uv sync` creates. With a non-editable one
+  (`uv sync --no-editable`, `uv pip install .`), `--cov=patchmatch` measures the unused
+  source tree and reports 0 %, and `python -m pytest` imports the source tree from the
+  repository root, without the compiled library.
 - `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`.
@@ -69,11 +62,11 @@ Other entry points:
 - `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).
+- `uv run --group gui gui/app.py` starts the Gradio GUI (paint holes, compare the fill).
+  No CI job installs gradio, so after API changes run its test with
+  `uv run --group gui pytest gui --no-cov` and try the GUI by hand.
+- CMake options: the `option()` lines of `CMakeLists.txt`. `PATCHMATCH_SANITIZE` turns
+  off fast math, which lets the compiler drop checks.
 
 ## Architecture
 
@@ -114,7 +107,8 @@ CMake installs the shared library into the package directory.
   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.
+- Comments explain why, in one short line where the code would otherwise be misread or
+  wrongly simplified; details and measurements go into the commit message.
 - 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.

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/CMakeLists.txt

@@ -57,8 +57,9 @@ if(PATCHMATCH_SANITIZE)
   endif()
   # GCC's -fsanitize=undefined leaves out float-cast-overflow
   set(PATCHMATCH_SANITIZERS -fsanitize=address,undefined,float-cast-overflow)
+  # -UNDEBUG keeps the asserts, which check the incremental distances of the propagation
   target_compile_options(patchmatch PRIVATE ${PATCHMATCH_SANITIZERS}
-    -fno-sanitize-recover=all -fno-omit-frame-pointer -g)
+    -fno-sanitize-recover=all -fno-omit-frame-pointer -g -UNDEBUG)
   target_link_options(patchmatch PRIVATE ${PATCHMATCH_SANITIZERS})
 endif()
 

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.1.0
+Version: 2.2.0b3
 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>
@@ -41,9 +41,12 @@ Description-Content-Type: text/markdown
 This library implements the PatchMatch based inpainting algorithm. It provides both C++
 and Python interfaces. This implementation is heavily based on the implementation by
 Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
-with some bug fixes, and updates.
+with some bug fixes, and updates. This repository continues
+[vacancy/PyPatchMatch](https://github.com/vacancy/PyPatchMatch) by Jiayuan Mao, through
+the forks [lkwq007/PyPatchMatch](https://github.com/lkwq007/PyPatchMatch) and
+[invoke-ai/PyPatchMatch](https://github.com/invoke-ai/PyPatchMatch).
 
-![Birdhouses removed from a photo by patchmatch.inpaint](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v2.1.0/examples/images/readme_example.jpg)
+![Birdhouses removed from a photo by patchmatch.inpaint](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v2.2.0b3/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)
@@ -98,7 +101,11 @@ The previous import path `from patchmatch import patch_match` keeps working.
 
 `patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
 pixels in each direction. Larger patches follow larger structures but are much slower;
-the default of 15 compares 31x31 patches, the examples use 3.
+the default of 15 compares 31x31 patches, the examples use 3. Below 5, the coarse levels
+that lay out the fill are also tried with a radius of 5, which is kept where it fits
+the surroundings better, so that repeating patterns continue across larger holes. Above
+7, coarse levels narrower than six patches use the largest radius that fits, but at
+least 7: larger patches found no sources there and left the fill flat.
 
 `patchmatch.set_random_seed(seed)` sets the seed of the randomized search, modulo
 `2**32`, and `patchmatch.set_verbose(True)` prints the progress of the native code to
@@ -136,8 +143,14 @@ uv run pre-commit install      # enable ruff and the other hooks on commit
 uv run pytest                  # run the test suite
 uv run pytest -m "not e2e"     # only the fast unit tests
 uv run python scripts/evaluate_inpainting.py  # measure the fill quality
+uv run --group gui gui/app.py  # draw masks in the browser, http://127.0.0.1:7860
 ```
 
+The GUI tries new images quickly, without writing a script for each one, e.g. to pick
+new examples or to verify edge cases: load an image, paint the holes (every painted
+pixel is one) and compare the original with the fill. Its test runs with
+`uv run --group gui pytest gui --no-cov`.
+
 The evaluation cuts holes into the images of `examples/images`, compares the fills with
 the original content and writes `examples/images/evaluation.html`, which shows them side
 by side. `--baseline` evaluates another build of the library as well, e.g. of the main

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/README.md

@@ -11,7 +11,10 @@
 This library implements the PatchMatch based inpainting algorithm. It provides both C++
 and Python interfaces. This implementation is heavily based on the implementation by
 Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
-with some bug fixes, and updates.
+with some bug fixes, and updates. This repository continues
+[vacancy/PyPatchMatch](https://github.com/vacancy/PyPatchMatch) by Jiayuan Mao, through
+the forks [lkwq007/PyPatchMatch](https://github.com/lkwq007/PyPatchMatch) and
+[invoke-ai/PyPatchMatch](https://github.com/invoke-ai/PyPatchMatch).
 
 ![Birdhouses removed from a photo by patchmatch.inpaint](examples/images/readme_example.jpg)
 
@@ -68,7 +71,11 @@ The previous import path `from patchmatch import patch_match` keeps working.
 
 `patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
 pixels in each direction. Larger patches follow larger structures but are much slower;
-the default of 15 compares 31x31 patches, the examples use 3.
+the default of 15 compares 31x31 patches, the examples use 3. Below 5, the coarse levels
+that lay out the fill are also tried with a radius of 5, which is kept where it fits
+the surroundings better, so that repeating patterns continue across larger holes. Above
+7, coarse levels narrower than six patches use the largest radius that fits, but at
+least 7: larger patches found no sources there and left the fill flat.
 
 `patchmatch.set_random_seed(seed)` sets the seed of the randomized search, modulo
 `2**32`, and `patchmatch.set_verbose(True)` prints the progress of the native code to
@@ -106,8 +113,14 @@ uv run pre-commit install      # enable ruff and the other hooks on commit
 uv run pytest                  # run the test suite
 uv run pytest -m "not e2e"     # only the fast unit tests
 uv run python scripts/evaluate_inpainting.py  # measure the fill quality
+uv run --group gui gui/app.py  # draw masks in the browser, http://127.0.0.1:7860
 ```
 
+The GUI tries new images quickly, without writing a script for each one, e.g. to pick
+new examples or to verify edge cases: load an image, paint the holes (every painted
+pixel is one) and compare the original with the fill. Its test runs with
+`uv run --group gui pytest gui --no-cov`.
+
 The evaluation cuts holes into the images of `examples/images`, compares the fills with
 the original content and writes `examples/images/evaluation.html`, which shows them side
 by side. `--baseline` evaluates another build of the library as well, e.g. of the main

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/patchmatch/_lib.py

@@ -82,8 +82,9 @@ def find_library() -> Path:
     )
 
 
-def load_library() -> ctypes.CDLL:
-    lib = ctypes.CDLL(str(find_library()))
+def load_library(path: Path | None = None) -> ctypes.CDLL:
+    """Load the installed library, or the build at ``path``."""
+    lib = ctypes.CDLL(str(path or find_library()))
 
     lib.PM_set_random_seed.argtypes = [ctypes.c_uint]
     lib.PM_set_random_seed.restype = None

{pypatchmatch-2.1.0 → pypatchmatch-2.2.0b3}/patchmatch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.0'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.2.0b3'
+__version_tuple__ = version_tuple = (2, 2, 0, 'b3')
 
-__commit_id__ = commit_id = 'g2f558d40a'
+__commit_id__ = commit_id = 'gc0f3bbfe6'