fuzzgpu 0.4.0__tar.gz → 0.4.1__tar.gz

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/Cargo.lock

@@ -91,9 +91,9 @@ checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
 
 [[package]]
 name = "bitflags"
-version = "2.13.1"
+version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "block2"
@@ -121,13 +121,13 @@ dependencies = [
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0e56a716f1e132ff6bf4bdac1c944a3fcdc1cae65f70a4a2a1ac3b401d2d1f"
+checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -249,9 +249,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.7"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -259,18 +259,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.20"
+version = "0.9.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.22"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
 
 [[package]]
 name = "crunchy"
@@ -372,7 +372,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "bytemuck",
  "criterion",
@@ -386,7 +386,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "fuzzgpu-core",
  "log",
@@ -504,15 +504,15 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
 
 [[package]]
 name = "indexmap"
-version = "2.14.0"
+version = "2.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
 dependencies = [
  "equivalent",
  "hashbrown 0.17.1",
@@ -574,9 +574,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.104"
+version = "0.3.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
+checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -955,9 +955,9 @@ checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 
 [[package]]
 name = "portable-atomic-util"
-version = "0.2.7"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
+checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
 dependencies = [
  "portable-atomic",
 ]
@@ -1312,7 +1312,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -1345,9 +1345,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.15.2"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
 
 [[package]]
 name = "spirv"
@@ -1377,9 +1377,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.3"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1431,7 +1431,7 @@ checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -1498,9 +1498,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.127"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70"
+checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1511,9 +1511,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.77"
+version = "0.4.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b7777d5cc23d0e91404e53ce2d5e8ec7acae3026b16233dba62cd3246457950"
+checksum = "6ef4c5d3d2cdf5c54f4231181768f5510842e350db025faf1f7163b1030ed928"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1521,9 +1521,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.127"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1"
+checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1531,22 +1531,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.127"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284"
+checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
 dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.5",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.127"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf"
+checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
 dependencies = [
  "unicode-ident",
 ]
@@ -1565,9 +1565,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.104"
+version = "0.3.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30"
+checksum = "9fbddc4a036f00ec4f18c83445bd3115cb306a91da554919a099d9222fe4a7f8"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1888,18 +1888,18 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.56"
+version = "0.8.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb"
+checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.56"
+version = "0.8.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1"
+checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
 dependencies = [
  "proc-macro2",
  "quote",

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.4.0
+Version: 0.4.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -38,7 +38,7 @@ Project-URL: Repository, https://github.com/kuntal-devrat/fuzzgpu
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
 [![PyPI 
-Version](https://img.shields.io/badge/pypi-v0.4.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+Version](https://img.shields.io/badge/pypi-v0.4.1-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.87+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -61,7 +61,21 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.4.0
+## What's New in v0.4.1
+
+### Production hardening & Performance
+- **Fail-fast contiguous buffer validation** — `*_into` zero-allocation APIs now validate numpy C-contiguity before any GPU/CPU dispatch, preventing wasted compute on strided arrays.
+- **RapidFuzz weighted Levenshtein parity** — `similarity`, `normalized_distance`, and `normalized_similarity` now support `weights=(1, 1, 1)` with exact weighted maximum distance calculation.
+- **Wavefront WGSL register optimization** — replaced ~1.5 KB private array stack copies with direct workgroup indexing in Gotoh affine gap DP.
+- **Zero-heap Myers SIMD fallback** — eliminated heap allocations on non-ASCII input paths with `std::str::from_utf8` / `Cow`.
+- **PEP 561 type safety** — shipped `py.typed` and comprehensive `.pyi` type stubs for all 54 public APIs and submodules.
+- **Community governance & Health files** — added CONTRIBUTING, CODE_OF_CONDUCT, SECURITY, and GitHub issue/PR templates.
+- **Cross-platform release CI** — made CPU wheel publishing portable across Linux, Windows, and macOS runners.
+
+---
+
+<details>
+<summary><b>Previous (v0.4.0)</b></summary>
 
 ### Production hardening
 - **WRatio score_cutoff parity** — WRatio now threads a rescaled running cutoff through its token/partial-token steps exactly as rapidfuzz does; high cutoffs no longer leak scaled token ratios (verified against rapidfuzz 3.14.5).
@@ -72,10 +86,7 @@ No NVIDIA CUDA drivers or complex toolkits required.
 - **Flaky stress asserts gated** — wall-clock budgets in `test_stress.py` are disabled via `FUZZGPU_SKIP_PERF_ASSERTS=1` (correctness checks always run).
 - **Accurate GPU timeout message** — readback timeouts now report the actual configured timeout.
 
-### Includes all v0.3.0 fixes
-All fixes from v0.3.0 are included.
-
----
+</details>
 
 <details>
 <summary><b>Previous (v0.3.0)</b></summary>
@@ -245,10 +256,16 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 pip install fuzzgpu
 ```
 
+For a smaller, dependency-light install with no GPU/WebGPU support (CPU + Rayon only):
+
+```bash
+pip install fuzzgpu-cpu
+```
+
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.4.0"
+fuzzgpu-core = "0.4.1"
 ```
 
 ---
@@ -268,7 +285,7 @@ candidates = ["hallo", "hullo", "jello", "yellow", "hello world"] * 10_000
 distances  = fuzzgpu.levenshtein_batch("hello", candidates)
 jw_scores  = fuzzgpu.jaro_winkler_batch("hello", candidates, p=0.1)
 nw_scores  = fuzzgpu.needleman_wunsch_affine_batch(
-    "AGTACGCA", candidates, match=2, mismatch=-1, gap_open=-3, gap_extend=-1
+    "AGTACGCA", candidates, match_score=2, mismatch_score=-1, gap_open=-3, gap_extend=-1
 )
 
 # ── Cross-product distance matrix ─────────────────────────────────────────────
@@ -344,12 +361,12 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.4.0"                                        # GPU + CPU fallback
-# fuzzgpu-core = { version = "0.4.0", default-features = false } # CPU-only
+fuzzgpu-core = "0.4.1"                                        # GPU + CPU fallback
+# fuzzgpu-core = { version = "0.4.1", default-features = false } # CPU-only
 ```
 
 ```rust
-use fuzzgpu_core::levenshtein::gpu_ext::GpuLevenshteinKernel;
+use fuzzgpu_core::GpuLevenshteinKernel;
 
 fn main() -> fuzzgpu_core::Result<()> {
     let kernel = GpuLevenshteinKernel::get()?;
@@ -490,7 +507,7 @@ cargo test --workspace
 | `FUZZGPU_DEBUG` | Log GPU→CPU fallback decisions |
 | `FUZZGPU_SIMD` | Force ISA: `portable\|neon\|avx2\|avx512` |
 | `FUZZGPU_READBACK_TIMEOUT_MS` | GPU readback timeout (default 10000 ms) |
-| `FUZZGPU_SKIP_DISPATCH_LOCK` | Opt-in GPU dispatch serialization (safety valve for the rare gfx-rs/wgpu#10085 crash class on Intel D3D12; dispatch is fully concurrent by default) |
+| `FUZZGPU_SERIALIZE_DISPATCH` | Opt-in GPU dispatch serialization (safety valve for rare driver heap corruption on Intel D3D12; dispatch is fully concurrent by default). Legacy alias: `FUZZGPU_SKIP_DISPATCH_LOCK` |
 | `FUZZGPU_REQUIRE_GPU` | In tests: fail instead of skip when no GPU |
 | `WGPU_BACKEND` | Force wgpu backend: `vulkan\|metal\|dx12` |
 | `PROPTEST_CASES` | Override proptest case count |

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/README.md

@@ -9,7 +9,7 @@
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
 [![PyPI 
-Version](https://img.shields.io/badge/pypi-v0.4.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+Version](https://img.shields.io/badge/pypi-v0.4.1-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.87+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -32,7 +32,21 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.4.0
+## What's New in v0.4.1
+
+### Production hardening & Performance
+- **Fail-fast contiguous buffer validation** — `*_into` zero-allocation APIs now validate numpy C-contiguity before any GPU/CPU dispatch, preventing wasted compute on strided arrays.
+- **RapidFuzz weighted Levenshtein parity** — `similarity`, `normalized_distance`, and `normalized_similarity` now support `weights=(1, 1, 1)` with exact weighted maximum distance calculation.
+- **Wavefront WGSL register optimization** — replaced ~1.5 KB private array stack copies with direct workgroup indexing in Gotoh affine gap DP.
+- **Zero-heap Myers SIMD fallback** — eliminated heap allocations on non-ASCII input paths with `std::str::from_utf8` / `Cow`.
+- **PEP 561 type safety** — shipped `py.typed` and comprehensive `.pyi` type stubs for all 54 public APIs and submodules.
+- **Community governance & Health files** — added CONTRIBUTING, CODE_OF_CONDUCT, SECURITY, and GitHub issue/PR templates.
+- **Cross-platform release CI** — made CPU wheel publishing portable across Linux, Windows, and macOS runners.
+
+---
+
+<details>
+<summary><b>Previous (v0.4.0)</b></summary>
 
 ### Production hardening
 - **WRatio score_cutoff parity** — WRatio now threads a rescaled running cutoff through its token/partial-token steps exactly as rapidfuzz does; high cutoffs no longer leak scaled token ratios (verified against rapidfuzz 3.14.5).
@@ -43,10 +57,7 @@ No NVIDIA CUDA drivers or complex toolkits required.
 - **Flaky stress asserts gated** — wall-clock budgets in `test_stress.py` are disabled via `FUZZGPU_SKIP_PERF_ASSERTS=1` (correctness checks always run).
 - **Accurate GPU timeout message** — readback timeouts now report the actual configured timeout.
 
-### Includes all v0.3.0 fixes
-All fixes from v0.3.0 are included.
-
----
+</details>
 
 <details>
 <summary><b>Previous (v0.3.0)</b></summary>
@@ -216,10 +227,16 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 pip install fuzzgpu
 ```
 
+For a smaller, dependency-light install with no GPU/WebGPU support (CPU + Rayon only):
+
+```bash
+pip install fuzzgpu-cpu
+```
+
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.4.0"
+fuzzgpu-core = "0.4.1"
 ```
 
 ---
@@ -239,7 +256,7 @@ candidates = ["hallo", "hullo", "jello", "yellow", "hello world"] * 10_000
 distances  = fuzzgpu.levenshtein_batch("hello", candidates)
 jw_scores  = fuzzgpu.jaro_winkler_batch("hello", candidates, p=0.1)
 nw_scores  = fuzzgpu.needleman_wunsch_affine_batch(
-    "AGTACGCA", candidates, match=2, mismatch=-1, gap_open=-3, gap_extend=-1
+    "AGTACGCA", candidates, match_score=2, mismatch_score=-1, gap_open=-3, gap_extend=-1
 )
 
 # ── Cross-product distance matrix ─────────────────────────────────────────────
@@ -315,12 +332,12 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.4.0"                                        # GPU + CPU fallback
-# fuzzgpu-core = { version = "0.4.0", default-features = false } # CPU-only
+fuzzgpu-core = "0.4.1"                                        # GPU + CPU fallback
+# fuzzgpu-core = { version = "0.4.1", default-features = false } # CPU-only
 ```
 
 ```rust
-use fuzzgpu_core::levenshtein::gpu_ext::GpuLevenshteinKernel;
+use fuzzgpu_core::GpuLevenshteinKernel;
 
 fn main() -> fuzzgpu_core::Result<()> {
     let kernel = GpuLevenshteinKernel::get()?;
@@ -461,7 +478,7 @@ cargo test --workspace
 | `FUZZGPU_DEBUG` | Log GPU→CPU fallback decisions |
 | `FUZZGPU_SIMD` | Force ISA: `portable\|neon\|avx2\|avx512` |
 | `FUZZGPU_READBACK_TIMEOUT_MS` | GPU readback timeout (default 10000 ms) |
-| `FUZZGPU_SKIP_DISPATCH_LOCK` | Opt-in GPU dispatch serialization (safety valve for the rare gfx-rs/wgpu#10085 crash class on Intel D3D12; dispatch is fully concurrent by default) |
+| `FUZZGPU_SERIALIZE_DISPATCH` | Opt-in GPU dispatch serialization (safety valve for rare driver heap corruption on Intel D3D12; dispatch is fully concurrent by default). Legacy alias: `FUZZGPU_SKIP_DISPATCH_LOCK` |
 | `FUZZGPU_REQUIRE_GPU` | In tests: fail instead of skip when no GPU |
 | `WGPU_BACKEND` | Force wgpu backend: `vulkan\|metal\|dx12` |
 | `PROPTEST_CASES` | Override proptest case count |

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-core"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 description = "GPU-accelerated fuzzy string matching engine"
 license = "MIT"

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/src/gpu.rs

@@ -25,21 +25,24 @@ pub fn require_gpu() -> bool {
         .unwrap_or(false)
 }
 
-/// Opt-in dispatch serialization (safety valve). `FUZZGPU_SKIP_DISPATCH_LOCK=1`
-/// re-enables the GPU-dispatch serialization that used to be the default
-/// workaround for the rare gfx-rs/wgpu#10085 crash class (heap corruption on
-/// Intel D3D12 under >=3 concurrent dispatchers on a shared device). Dispatch
-/// is fully concurrent by default; set this env var on affected Intel hardware
-/// to serialize both the production dispatch path and the test suite.
+/// Opt-in dispatch serialization (safety valve). `FUZZGPU_SERIALIZE_DISPATCH=1`
+/// (or legacy alias `FUZZGPU_SKIP_DISPATCH_LOCK=1`) re-enables the GPU-dispatch
+/// serialization that used to be the default workaround for the rare gfx-rs/wgpu#10085
+/// crash class (heap corruption on Intel D3D12 under >=3 concurrent dispatchers on a
+/// shared device). Dispatch is fully concurrent by default; set this env var on affected
+/// Intel hardware to serialize both the production dispatch path and the test suite.
 pub(crate) fn dispatch_serialize() -> bool {
-    std::env::var("FUZZGPU_SKIP_DISPATCH_LOCK")
-        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
-        .unwrap_or(false)
+    let check = |var: &str| {
+        std::env::var(var)
+            .map(|v| v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes"))
+            .unwrap_or(false)
+    };
+    check("FUZZGPU_SERIALIZE_DISPATCH") || check("FUZZGPU_SKIP_DISPATCH_LOCK")
 }
 
 /// Serialize GPU access across tests. Only active when
-/// `FUZZGPU_SKIP_DISPATCH_LOCK=1` (opt-in safety valve); by default returns
-/// `None` so the test suite runs with fully concurrent GPU dispatch.
+/// `FUZZGPU_SERIALIZE_DISPATCH=1` or `FUZZGPU_SKIP_DISPATCH_LOCK=1` (opt-in safety valve);
+/// by default returns `None` so the test suite runs with fully concurrent GPU dispatch.
 pub fn gpu_test_lock() -> Option<std::sync::MutexGuard<'static, ()>> {
     if !dispatch_serialize() {
         return None;
@@ -802,13 +805,25 @@ mod tests {
         disarm_shader_error_fault();
     }
 
-    /// dispatch_serialize must read FUZZGPU_SKIP_DISPATCH_LOCK and return
-    /// true only when it is set to '1' or 'true' (case-insensitive). The
+    /// dispatch_serialize must read FUZZGPU_SERIALIZE_DISPATCH or FUZZGPU_SKIP_DISPATCH_LOCK
+    /// and return true only when set to '1' or 'true' (case-insensitive). The
     /// serialization is opt-in: unset (default) means fully concurrent.
     #[test]
     fn test_dispatch_serialize_opt_in() {
+        std::env::remove_var("FUZZGPU_SERIALIZE_DISPATCH");
         std::env::remove_var("FUZZGPU_SKIP_DISPATCH_LOCK");
         assert!(!dispatch_serialize());
+
+        // Primary self-documenting variable
+        std::env::set_var("FUZZGPU_SERIALIZE_DISPATCH", "1");
+        assert!(dispatch_serialize());
+        std::env::set_var("FUZZGPU_SERIALIZE_DISPATCH", "true");
+        assert!(dispatch_serialize());
+        std::env::set_var("FUZZGPU_SERIALIZE_DISPATCH", "0");
+        assert!(!dispatch_serialize());
+        std::env::remove_var("FUZZGPU_SERIALIZE_DISPATCH");
+
+        // Backward-compatible alias
         std::env::set_var("FUZZGPU_SKIP_DISPATCH_LOCK", "1");
         assert!(dispatch_serialize());
         std::env::set_var("FUZZGPU_SKIP_DISPATCH_LOCK", "true");

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/src/lib.rs

@@ -7,8 +7,16 @@ pub mod levenshtein;
 pub mod needleman;
 pub mod simd;
 
+#[cfg(feature = "gpu")]
+pub use damerau::gpu_ext::GpuDamerauKernel;
 #[cfg(feature = "gpu")]
 pub use gpu::{GpuEngine, GpuInfo, Result};
+#[cfg(feature = "gpu")]
+pub use jaro::gpu_ext::GpuJaroKernel;
+#[cfg(feature = "gpu")]
+pub use levenshtein::gpu_ext::GpuLevenshteinKernel;
+#[cfg(feature = "gpu")]
+pub use needleman::gpu_ext::GpuNeedlemanAffineKernel;
 
 #[cfg(not(feature = "gpu"))]
 pub type Result<T> = std::result::Result<T, String>;

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/src/shaders/needleman_wavefront.wgsl

@@ -104,8 +104,8 @@ fn main(
             let j = j_start + t;
             let i = k - j;
 
-            let prev = diags[(k - 1u) % 3u];
-            let prev2 = diags[(k - 2u) % 3u];
+            let prev_idx = (k - 1u) % 3u;
+            let prev2_idx = (k - 2u) % 3u;
 
             var cell: State;
             if (i == 0u) {
@@ -122,18 +122,18 @@ fn main(
                 let sub = select(params.mismatch_score, params.match_score, a_char == b_char);
 
                 // M(i,j) = max(M,Ix,Iy)(i-1,j-1) + sub   -- diagonal k-2.
-                let best_diag = max(prev2[j - 1u].m, max(prev2[j - 1u].ix, prev2[j - 1u].iy));
+                let best_diag = max(diags[prev2_idx][j - 1u].m, max(diags[prev2_idx][j - 1u].ix, diags[prev2_idx][j - 1u].iy));
                 let cell_m = best_diag + sub;
 
                 // Ix(i,j) from (i,j-1) -- diagonal k-1, column j-1.
-                let cell_ix = max(prev[j - 1u].ix + params.gap_extend,
-                    max(prev[j - 1u].m + params.gap_open + params.gap_extend,
-                        prev[j - 1u].iy + params.gap_open + params.gap_extend));
+                let cell_ix = max(diags[prev_idx][j - 1u].ix + params.gap_extend,
+                    max(diags[prev_idx][j - 1u].m + params.gap_open + params.gap_extend,
+                        diags[prev_idx][j - 1u].iy + params.gap_open + params.gap_extend));
 
                 // Iy(i,j) from (i-1,j) -- diagonal k-1, column j.
-                let cell_iy = max(prev[j].iy + params.gap_extend,
-                    max(prev[j].m + params.gap_open + params.gap_extend,
-                        prev[j].ix + params.gap_open + params.gap_extend));
+                let cell_iy = max(diags[prev_idx][j].iy + params.gap_extend,
+                    max(diags[prev_idx][j].m + params.gap_open + params.gap_extend,
+                        diags[prev_idx][j].ix + params.gap_open + params.gap_extend));
 
                 cell = State(cell_m, cell_ix, cell_iy);
             }

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/src/simd.rs

@@ -19,9 +19,15 @@ pub fn levenshtein_myers(a: &[u8], b: &[u8]) -> u32 {
     // back to the Unicode path. Assert it here so direct Rust callers can't
     // silently get byte-semantics results.
     if !a.is_ascii() || !b.is_ascii() {
-        let a = String::from_utf8_lossy(a);
-        let b = String::from_utf8_lossy(b);
-        return crate::levenshtein::levenshtein_distance_raw(&a, &b);
+        let a_str = match std::str::from_utf8(a) {
+            Ok(s) => std::borrow::Cow::Borrowed(s),
+            Err(_) => String::from_utf8_lossy(a),
+        };
+        let b_str = match std::str::from_utf8(b) {
+            Ok(s) => std::borrow::Cow::Borrowed(s),
+            Err(_) => String::from_utf8_lossy(b),
+        };
+        return crate::levenshtein::levenshtein_distance_raw(&a_str, &b_str);
     }
     let (m, n) = (a.len(), b.len());
     if m == 0 {

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/tests/differential.rs

@@ -43,6 +43,7 @@ fn any_string(max_len: usize) -> impl Strategy<Value = String> {
 
 /// ASCII string, length `1..=max_len` (non-empty: the row-wise Myers cdist
 /// kernel requires a non-empty pattern per row).
+#[allow(dead_code)]
 fn ascii_string_nz(max_len: usize) -> impl Strategy<Value = String> {
     (1usize..=max_len).prop_flat_map(move |len| {
         prop::collection::vec(prop::char::range('a', 'z'), len..=len)
@@ -50,12 +51,14 @@ fn ascii_string_nz(max_len: usize) -> impl Strategy<Value = String> {
     })
 }
 
+#[allow(dead_code)]
 fn any_pair(max_len: usize) -> impl Strategy<Value = (String, String)> {
     (any_string(max_len), any_string(max_len))
 }
 
 /// A pair of ASCII strings (the GPU Damerau kernel's gate is ASCII ≤ 32
 /// chars, so ASCII pairs are what actually runs on the shader).
+#[allow(dead_code)]
 fn ascii_pair(max_len: usize) -> impl Strategy<Value = (String, String)> {
     (ascii_string(max_len), ascii_string(max_len))
 }

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-core/tests/kernel_registration.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "gpu")]
+
 //! End-to-end coverage of the `FuzzGpuError::ShaderError` path from the
 //! public API.
 //!

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-python"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 description = "Python bindings for FuzzGPU: GPU-accelerated fuzzy string matching engine"
 license = "MIT"
@@ -17,7 +17,7 @@ default = ["gpu"]
 gpu = ["fuzzgpu-core/gpu"]
 
 [dependencies]
-fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.4.0", default-features = false }
+fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.4.1", default-features = false }
 pyo3 = { workspace = true, features = ["abi3-py310"] }
 numpy = "0.29"
 pollster = { workspace = true }

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-python/src/lib.rs

@@ -1,5 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyString, PyStringMethods};
+#[cfg(feature = "gpu")]
 use std::sync::OnceLock;
 
 #[cfg(feature = "gpu")]
@@ -7,9 +8,12 @@ use fuzzgpu_core::gpu::GpuEngine;
 
 // ── Cached Environment Configuration ─────────────────────────
 
+#[cfg(feature = "gpu")]
 static FORCE_GPU_CACHE: OnceLock<bool> = OnceLock::new();
+#[cfg(feature = "gpu")]
 static DEBUG_CACHE: OnceLock<bool> = OnceLock::new();
 
+#[cfg(feature = "gpu")]
 #[inline]
 fn is_force_gpu() -> bool {
     *FORCE_GPU_CACHE.get_or_init(|| {
@@ -21,6 +25,7 @@ fn is_force_gpu() -> bool {
     })
 }
 
+#[cfg(feature = "gpu")]
 #[inline]
 fn is_debug_mode() -> bool {
     *DEBUG_CACHE.get_or_init(|| {
@@ -95,7 +100,7 @@ fn checked_u32_array1<'py>(
 ) -> PyResult<numpy::PyReadwriteArray1<'py, u32>> {
     use numpy::{PyArray1, PyUntypedArrayMethods};
     let arr = out.cast::<PyArray1<u32>>()?;
-    let rw = readwrite_or_err(arr)?;
+    let mut rw = readwrite_or_err(arr)?;
     if rw.len() != expected {
         return Err(pyo3::exceptions::PyValueError::new_err(format!(
             "out must hold exactly {} uint32 elements, got {}",
@@ -103,6 +108,11 @@ fn checked_u32_array1<'py>(
             rw.len()
         )));
     }
+    if rw.as_slice_mut().is_err() {
+        return Err(pyo3::exceptions::PyBufferError::new_err(
+            "out must be C-contiguous",
+        ));
+    }
     Ok(rw)
 }
 
@@ -114,7 +124,7 @@ fn checked_f64_array1<'py>(
 ) -> PyResult<numpy::PyReadwriteArray1<'py, f64>> {
     use numpy::{PyArray1, PyUntypedArrayMethods};
     let arr = out.cast::<PyArray1<f64>>()?;
-    let rw = readwrite_or_err(arr)?;
+    let mut rw = readwrite_or_err(arr)?;
     if rw.len() != expected {
         return Err(pyo3::exceptions::PyValueError::new_err(format!(
             "out must hold exactly {} float64 elements, got {}",
@@ -122,6 +132,11 @@ fn checked_f64_array1<'py>(
             rw.len()
         )));
     }
+    if rw.as_slice_mut().is_err() {
+        return Err(pyo3::exceptions::PyBufferError::new_err(
+            "out must be C-contiguous",
+        ));
+    }
     Ok(rw)
 }
 
@@ -134,13 +149,18 @@ fn checked_u32_array2<'py>(
 ) -> PyResult<numpy::PyReadwriteArray2<'py, u32>> {
     use numpy::{PyArray2, PyUntypedArrayMethods};
     let arr = out.cast::<PyArray2<u32>>()?;
-    let rw = readwrite_or_err(arr)?;
+    let mut rw = readwrite_or_err(arr)?;
     if rw.shape() != [rows, cols] {
         return Err(pyo3::exceptions::PyValueError::new_err(format!(
             "out must have shape ({rows}, {cols}), got {:?}",
             rw.shape()
         )));
     }
+    if rw.as_slice_mut().is_err() {
+        return Err(pyo3::exceptions::PyBufferError::new_err(
+            "out must be C-contiguous",
+        ));
+    }
     Ok(rw)
 }
 
@@ -153,13 +173,18 @@ fn checked_f64_array2<'py>(
 ) -> PyResult<numpy::PyReadwriteArray2<'py, f64>> {
     use numpy::{PyArray2, PyUntypedArrayMethods};
     let arr = out.cast::<PyArray2<f64>>()?;
-    let rw = readwrite_or_err(arr)?;
+    let mut rw = readwrite_or_err(arr)?;
     if rw.shape() != [rows, cols] {
         return Err(pyo3::exceptions::PyValueError::new_err(format!(
             "out must have shape ({rows}, {cols}), got {:?}",
             rw.shape()
         )));
     }
+    if rw.as_slice_mut().is_err() {
+        return Err(pyo3::exceptions::PyBufferError::new_err(
+            "out must be C-contiguous",
+        ));
+    }
     Ok(rw)
 }
 
@@ -370,11 +395,11 @@ fn damerau_levenshtein_distance(py: Python, a: &str, b: &str) -> PyResult<u32> {
 /// Shared compute for `damerau_levenshtein_batch` / `..._into`: GPU
 /// Lowrance-Wagner kernel (auto-routed, CPU fallback).
 fn damerau_batch_core(py: Python<'_>, query: &str, cands: &[&str]) -> PyResult<Vec<u32>> {
-    let pairs: Vec<(&str, &str)> = cands.iter().map(|c| (query, *c)).collect();
     #[cfg(feature = "gpu")]
     {
         if !GpuEngine::is_cpu_only() {
             if let Ok(kernel) = fuzzgpu_core::damerau::gpu_ext::GpuDamerauKernel::get() {
+                let pairs: Vec<(&str, &str)> = cands.iter().map(|c| (query, *c)).collect();
                 match py.detach(|| kernel.compute_batch(&pairs)) {
                     Ok(res) => return Ok(res),
                     Err(e) => {

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/crates/fuzzgpu-wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-wasm"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 
 [workspace]

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fuzzgpu"
-version = "0.4.0"
+version = "0.4.1"
 description = "Hardware-accelerated fuzzy string matching & sequence alignment — cross-platform, no CUDA required"
 readme = "README.md"
 license = { text = "MIT" }

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/python/fuzzgpu/__init__.pyi

@@ -5,6 +5,10 @@ from typing import Callable, Iterable, Optional, Sequence, Tuple
 import numpy as np
 from numpy.typing import NDArray
 
+from . import fuzz as fuzz
+from . import process as process
+from . import distance as distance
+
 Processor = Optional[Callable[[str], str]]
 Scorer = Callable[..., float]
 
@@ -34,6 +38,7 @@ def damerau_ratio(a: str, b: str) -> float: ...
 def needleman_wunsch_score(a: str, b: str, match_score: int, mismatch_score: int, gap_penalty: int) -> int: ...
 def needleman_wunsch(a: str, b: str, match_score: int, mismatch_score: int, gap_penalty: int) -> int: ...
 def needleman_wunsch_batch(query: str, candidates: Sequence[str], match_score: int, mismatch_score: int, gap_penalty: int) -> list[int]: ...
+def needleman_wunsch_batch_fn(query: str, candidates: Sequence[str], match_score: int, mismatch_score: int, gap_penalty: int) -> list[int]: ...
 def needleman_wunsch_affine(a: str, b: str, match_score: int, mismatch_score: int, gap_open: int, gap_extend: int) -> int: ...
 def needleman_wunsch_affine_batch(query: str, candidates: Sequence[str], match_score: int, mismatch_score: int, gap_open: int, gap_extend: int) -> list[int]: ...
 def needleman_wunsch_striped(a: str, b: str, match_score: int, mismatch_score: int, gap_penalty: int) -> int: ...
@@ -45,6 +50,7 @@ def jaro_winkler_similarity(a: str, b: str, p: float = 0.1) -> float: ...
 def jaro_winkler(a: str, b: str, p: float = 0.1) -> float: ...
 def jaro_optimized(a: str, b: str) -> float: ...
 def jaro_winkler_batch(query: str, candidates: Sequence[str], p: float = 0.1) -> list[float]: ...
+def jaro_winkler_batch_fn(query: str, candidates: Sequence[str], p: float = 0.1) -> list[float]: ...
 def jaro_winkler_batch_into(query: str, candidates: Sequence[str], out: NDArray[np.float64], p: float = 0.1) -> None: ...
 def jaro_winkler_cdist(list_a: Sequence[str], list_b: Sequence[str], p: float = 0.1) -> list[list[float]]: ...
 def jaro_winkler_cdist_into(list_a: Sequence[str], list_b: Sequence[str], out: NDArray[np.float64], p: float = 0.1) -> None: ...
@@ -66,6 +72,22 @@ def WRatio(s1: str, s2: str, *, processor: Processor = None, score_cutoff: float
 def wratio(s1: str, s2: str, *, processor: Processor = None, score_cutoff: float = 0.0) -> float: ...
 def ratio_batch(query: str, candidates: Sequence[str], *, processor: Processor = None, score_cutoff: float = 0.0, workers: Optional[int] = None) -> list[float]: ...
 
+# ── Native extension exports ──────────────────────────────────
+def fuzz_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_partial_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_partial_ratio_alignment(a: str, b: str, score_cutoff: float = 0.0) -> Tuple[float, int, int, int, int]: ...
+def fuzz_token_sort_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_token_set_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_token_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_wratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_ratio_batch(query: str, candidates: Sequence[str]) -> list[float]: ...
+def fuzz_extract(query: str, choices: Sequence[str], score_cutoff: float = 0.0, limit: int = 5) -> list[Tuple[str, float, int]]: ...
+def fuzz_extract_one(query: str, choices: Sequence[str], score_cutoff: float = 0.0) -> Optional[Tuple[str, float, int]]: ...
+def fuzz_partial_token_sort_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_partial_token_set_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_partial_token_ratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+def fuzz_qratio(a: str, b: str, score_cutoff: float = 0.0) -> float: ...
+
 # ── Search ───────────────────────────────────────────────────
 def extract(
     query: str,
@@ -101,15 +123,10 @@ def extract_one(
     scorer_kwargs: Optional[dict] = None,
 ) -> Optional[Tuple[str, float, int]]: ...
 
-# ── Utilities ────────────────────────────────────────────────
-def set_cpu_only(cpu_only: bool) -> None: ...
-def set_gpu_threshold(threshold: Optional[int]) -> None: ...
-def is_gpu_available() -> bool: ...
-def warmup() -> tuple[bool, str]: ...
-def gpu_info() -> str: ...
-def hardware_info() -> str: ...
-
 # ── Alignment helpers (rapidfuzz.distance API) ───────────────
+def editops(s1: str, s2: str) -> Editops: ...
+def opcodes(s1: str, s2: str) -> Opcodes: ...
+
 class Editop(Tuple[str, int, int]):
     tag: str
     src_pos: int
@@ -166,3 +183,13 @@ class ScoreAlignment(Tuple[float, int, int, int, int]):
     src_end: int
     dest_start: int
     dest_end: int
+
+# ── Utilities ────────────────────────────────────────────────
+def set_cpu_only(cpu_only: bool) -> None: ...
+def set_gpu_threshold(threshold: Optional[int]) -> None: ...
+def is_gpu_available() -> bool: ...
+def warmup() -> tuple[bool, str]: ...
+def gpu_info() -> str: ...
+def hardware_info() -> str: ...
+
+__all__: list[str]

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/python/fuzzgpu/distance/Levenshtein.py

@@ -27,30 +27,42 @@ def distance(s1, s2, *, weights=(1, 1, 1), processor=None, score_cutoff=None, sc
     return cutoff_distance(value, score_cutoff)
 
 
-def similarity(s1, s2, *, processor=None, score_cutoff=None, score_hint=None):
+def _max_distance(len1, len2, weights):
+    if weights == (1, 1, 1):
+        return max(len1, len2)
+    ins, dele, sub = weights
+    s = min(sub, ins + dele)
+    if len1 >= len2:
+        return len2 * s + (len1 - len2) * dele
+    else:
+        return len1 * s + (len2 - len1) * ins
+
+
+def similarity(s1, s2, *, weights=(1, 1, 1), processor=None, score_cutoff=None, score_hint=None):
     del score_hint
     if processor:
         s1, s2 = processor(s1), processor(s2)
     # Compute maximum AFTER processing so len() reflects the processed strings.
-    maximum = max(len(s1), len(s2))
-    value = maximum - distance(s1, s2)
+    maximum = _max_distance(len(s1), len(s2), weights)
+    value = maximum - distance(s1, s2, weights=weights)
     return value if score_cutoff is None or value >= score_cutoff else 0
 
 
-def normalized_distance(s1, s2, *, processor=None, score_cutoff=None, score_hint=None):
+def normalized_distance(s1, s2, *, weights=(1, 1, 1), processor=None, score_cutoff=None, score_hint=None):
     del score_hint
     if processor:
         s1, s2 = processor(s1), processor(s2)
-    maximum = max(len(s1), len(s2))
-    value = _normalized(distance(s1, s2), maximum)
+    maximum = _max_distance(len(s1), len(s2), weights)
+    value = _normalized(distance(s1, s2, weights=weights), maximum)
     return value if score_cutoff is None or value <= score_cutoff else 1.0
 
 
-def normalized_similarity(s1, s2, *, processor=None, score_cutoff=None, score_hint=None):
+def normalized_similarity(s1, s2, *, weights=(1, 1, 1), processor=None, score_cutoff=None, score_hint=None):
     del score_hint
     if processor:
         s1, s2 = processor(s1), processor(s2)
-    value = 1.0 - _normalized(distance(s1, s2), max(len(s1), len(s2)))
+    maximum = _max_distance(len(s1), len(s2), weights)
+    value = 1.0 - _normalized(distance(s1, s2, weights=weights), maximum)
     return value if score_cutoff is None or value >= score_cutoff else 0.0
 
 

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/python/fuzzgpu/fuzz.pyi

@@ -40,6 +40,20 @@ def extractOne(
 extract_one = extractOne
 damerau_ratio: Callable[[str, str], float]
 
+def cdist(
+    queries: Iterable[str],
+    choices: Iterable[str],
+    *,
+    scorer: Optional[Callable] = ...,
+    processor: Optional[Processor] = ...,
+    score_cutoff: Optional[float] = ...,
+    score_hint: Optional[float] = ...,
+    score_multiplier: float = ...,
+    dtype: Optional[object] = ...,
+    workers: Optional[int] = ...,
+    scorer_kwargs: Optional[dict] = ...,
+) -> object: ...
+
 class ScoreAlignment(Tuple[float, int, int, int, int]):
     score: float
     src_start: int

fuzzgpu-0.4.1/python/fuzzgpu/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/tests/test_out_buffers.py

@@ -144,6 +144,14 @@ def test_cdist_into_non_contiguous_raises():
         fuzzgpu.levenshtein_cdist_into(a, b, out)
 
 
+def test_batch_into_non_contiguous_raises():
+    query = "hello"
+    cands = ["world", "help"]
+    out = np.zeros(4, dtype=np.uint32)[::2]  # strided 1D view
+    with pytest.raises(BufferError, match=r"C-contiguous"):
+        fuzzgpu.levenshtein_batch_into(query, cands, out)
+
+
 def test_jaro_batch_into_invalid_p_raises():
     out = np.zeros(1, dtype=np.float64)
     with pytest.raises(ValueError):

{fuzzgpu-0.4.0 → fuzzgpu-0.4.1}/tests/test_rapidfuzz_differential.py

@@ -98,6 +98,19 @@ def test_distance_modules_match_rapidfuzz(mod, fn):
             assert r == g, f"{mod}.{fn}({a!r}, {b!r}): rapidfuzz={r} fuzzgpu={g}"
 
 
+@pytest.mark.parametrize("fn", ["distance", "similarity", "normalized_distance", "normalized_similarity"])
+@pytest.mark.parametrize("weights", [(1, 1, 1), (1, 1, 2), (2, 1, 1), (1, 2, 1), (2, 3, 4)])
+def test_levenshtein_weighted_matches_rapidfuzz(fn, weights):
+    rmod, gmod = rd.Levenshtein, fd.Levenshtein
+    for a, b in _PAIRS[:20]:
+        r = getattr(rmod, fn)(a, b, weights=weights)
+        g = getattr(gmod, fn)(a, b, weights=weights)
+        if isinstance(r, float):
+            _assert_close(r, g, f"Levenshtein.{fn}({a!r}, {b!r}, weights={weights})")
+        else:
+            assert r == g, f"Levenshtein.{fn}({a!r}, {b!r}, weights={weights}): rapidfuzz={r} fuzzgpu={g}"
+
+
 @pytest.mark.parametrize("mod", ["Levenshtein", "Indel"])
 def test_editops_length_matches_rapidfuzz(mod):
     rmod, gmod = getattr(rd, mod), getattr(fd, mod)