fuzzgpu 0.1.6__tar.gz → 0.1.8__tar.gz

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/Cargo.lock

@@ -372,7 +372,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
  "bytemuck",
  "criterion",
@@ -386,7 +386,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
  "fuzzgpu-core",
  "log",

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.1.6
+Version: 0.1.8
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,7 +37,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.1.6-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.8-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)
@@ -60,34 +60,82 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.1.6
+## What's New in v0.1.8
+
+### Production hardening
+- **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
+  `GpuJaroKernel`, `GpuNeedlemanAffineKernel`, `GpuDamerauKernel`) previously called
+  `.unwrap()` on `OnceLock::get()` after initialization, which could panic the Python
+  interpreter under rare concurrent races. Replaced with `.ok_or_else(...)` returning
+  a proper `FuzzGpuError::NoDevice`.
+- **`debug_assert!` → real release guards** — `MyersPattern::new`, `jaro_bitpar`, `jaro_4way`
+  were guarded only by `debug_assert!`. In release builds, calling them with inputs outside
+  their contract (non-ASCII or > 64 bytes) would silently produce wrong results. Promoted to
+  proper `assert!` with descriptive messages that surface immediately in both debug and release.
+
+### New API surface
+- **`fuzz.cdist`** — pairwise score matrix, mirrors `rapidfuzz.fuzz.cdist`. Delegates to
+  `process.cdist` with `ratio` as the default scorer.
+- **`DamerauLevenshtein.editops` / `.opcodes`** — full Lowrance-Wagner traceback returning
+  `Editops` / `Opcodes` (insert/delete/replace), completing parity with rapidfuzz's alignment
+  API for this module.
+- **`fuzz.__all__`** now includes `partial_ratio_alignment` and `cdist` (were missing).
+
+### API correctness fixes
+- **`Jaro.similarity` / `JaroWinkler.similarity` `score_cutoff`** — changed default from
+  `0.0` to `None`, matching rapidfuzz's semantics (`0.0` treated scores of exactly 0.0 as
+  filtered, which was wrong).
+- **`ratio_batch(workers=)`** — was silently ignored (`del workers`). Now wires up a
+  `ThreadPoolExecutor` for the processor path; the no-processor path continues to use Rayon
+  internally (ignoring `workers` is correct there — Rayon already uses all cores).
+- **`process.cdist` fast path** — rewrote to use `fuzz_ratio_batch` row-by-row (each row
+  runs under Rayon across all cores) instead of a dead `raw = _native.fuzz_ratio_batch`
+  assignment followed by the same loop. Removed the dead `raw:` type-hint-only line.
+- **`process.cdist` silent swallow** — `except Exception: pass` replaced with
+  `warnings.warn(...)` so unexpected fast-path failures are visible instead of silently
+  producing slow results.
+
+### Includes all v0.1.7 fixes
+All fixes from v0.1.7 are included — see the v0.1.7 changelog below.
+
+---
+
+<details>
+<summary><b>Previous (v0.1.7)</b></summary>
+
+### Bug fixes (Windows DX12 / Jaro shader)
+- **Jaro GPU shader FXC crash fixed** — `jaro.wgsl` and `jaro_matrix.wgsl` used dynamic vector
+  component writes (`v[j >> 5u] = ...`) in `bit_set()`. Fixed by rewriting `bit_set` with
+  `select()`-based static construction (Vulkan, Metal, DX12 all compile identically).
+
+### Bug fixes (arity mismatch — wasm & fuzz crates)
+- **`fuzzgpu-wasm`** and **`fuzzgpu-fuzz`** — 4 × `E0061` arity mismatch for
+  `partial_ratio`/`token_sort_ratio`/`token_set_ratio`/`wratio`. Fixed by passing `0.0`
+  as the cutoff.
+
+</details>
+
+<details>
+<summary><b>Previous (v0.1.6)</b></summary>
 
 ### Drop-in rapidfuzz parity (Python)
 The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-pair differential harness across `ratio`, `partial_ratio`, `token_sort_ratio`, `token_set_ratio`, `token_ratio`, `WRatio`, `QRatio`, `partial_token_*`, `jaro`, `jaro_winkler`, `levenshtein`, `indel`, `hamming`, `osa` — **0 mismatches**.
 
 ### Bug fixes (Rust core, float parity)
-- **`ratio` / `partial_ratio` cutoff imprecision** — port of rapidfuzz's load-bearing `NormSim_to_NormDist = min(1, 1 - cutoff/100 + 1e-5)` term. Without it, the branch-and-bound would silently reject ties at exact cutoffs (e.g. `partial_ratio("park", "ba", score_cutoff=50.0)` returned `0` instead of `50`).
-- **`ratio` score formula** — switched from `((len-dist)/len)*100` to `(1 - dist/len)*100` to match rapidfuzz C++'s exact ulp order (`indel_normalized_similarity * 100`).
+- **`ratio` / `partial_ratio` cutoff imprecision** — port of rapidfuzz's load-bearing `NormSim_to_NormDist = min(1, 1 - cutoff/100 + 1e-5)` term.
+- **`ratio` score formula** — switched from `((len-dist)/len)*100` to `(1 - dist/len)*100` to match rapidfuzz C++'s exact ulp order.
 
 ### New features (Python distance layer)
-- **`Editops` / `Opcodes` / `Editop` / `Opcode` / `MatchingBlock` / `ScoreAlignment`** classes (rapidfuzz-compatible list-/tuple-likes with `as_list`, `as_opcodes`, `as_editops`, `as_matching_blocks`, `apply`, `inverse`, `remove_subsequence`, `from_*`).
-- **`Levenshtein.editops` / `.opcodes`** — exact Myers bit-parallel port with `common_affix` (suffix measured on post-prefix slice, matching rapidfuzz).
-- **`LCSseq`** module — Myers LCS bit-parallel matrix + editops/opcodes (delete-checked-first traceback).
-- **`Prefix`** and **`Postfix`** modules with the C++ `1 - dist/maximum` ulp order.
-- **`Hamming.editops` / `.opcodes`** — replace-per-mismatch + padding delete/insert model.
-- **`Indel.editops` / `.opcodes`** — delegates to `LCSseq` (matching rapidfuzz C++).
-- **`fuzz.partial_ratio_alignment`** now returns `ScoreAlignment(score, src_start, src_end, dest_start, dest_end)` — drop-in compatible with rapidfuzz.
-- **`process.extract` / `extractOne` / `cdist`** default to `WRatio` (matches rapidfuzz 3.14.5).
-- **`token_ratio` / `partial_token_ratio`** exposed at top level (`fuzzgpu.token_ratio`, `fuzzgpu.partial_token_ratio`).
-- All alignment types re-exported at the package root (`fuzzgpu.Editop`, `fuzzgpu.Editops`, etc.).
-
-### Type stubs
-- `__init__.pyi`, `fuzz.pyi`, `process.pyi`, `distance/__init__.pyi` updated for the new APIs.
+- **`Editops` / `Opcodes` / `Editop` / `Opcode` / `MatchingBlock` / `ScoreAlignment`** classes (rapidfuzz-compatible).
+- **`Levenshtein.editops` / `.opcodes`**, **`LCSseq`**, **`Prefix`**, **`Postfix`**, **`Hamming.editops`**, **`Indel.editops`** modules.
+- **`fuzz.partial_ratio_alignment`** returns `ScoreAlignment` (rapidfuzz-compatible).
+- **`process.extract` / `extractOne` / `cdist`** default to `WRatio`.
+- All alignment types re-exported at the package root.
 
----
+</details>
 
 <details>
-<summary><b>Previous (v0.1.5</b</summary>
+<summary><b>Previous (v0.1.5)</b></summary>
 
 ### Bug fixes
 - **Damerau-Levenshtein safety gate** now fires in release builds (`assert!` not `debug_assert!`) — non-ASCII inputs no longer silently produce wrong distances in production wheels
@@ -116,26 +164,53 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 ## Benchmark Results
 
 *Hardware: Intel(R) Iris(R) Xe Graphics (Vulkan) + Intel Core i7 (Rayon uses all cores)*
-*Versions: fuzzgpu 0.1.6 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Versions: fuzzgpu 0.1.8 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
 *Median of 7 runs after warmup. Reproduce: `python benchmarks/bench_compare.py`*
 
 ### Levenshtein Batch (1 query × N candidates, 10-char strings)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **100** | 0.12 ms | 0.01 ms | 0.03 ms | 0.25× | 2.21× |
-| **1,000** | 0.83 ms | 0.09 ms | 0.15 ms | 0.18× | 1.67× |
-| **10,000** | 2.60 ms | 0.87 ms | 1.47 ms | 0.57× | 1.68× |
-| **50,000** | 9.92 ms | 5.04 ms | 6.38 ms | 0.64× | 1.27× |
+| **100** | 0.04 ms | 0.00 ms | 0.01 ms | 0.24× | 1.90× |
+| **1,000** | 0.50 ms | 0.04 ms | 0.07 ms | 0.13× | 1.89× |
+| **10,000** | 1.53 ms | 0.40 ms | 0.64 ms | 0.42× | 1.61× |
+| **50,000** | 6.87 ms | 3.36 ms | 4.46 ms | 0.65× | 1.33× |
 
 ### Damerau-Levenshtein Batch (unrestricted Lowrance-Wagner)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **1,000** | 0.58 ms | 0.40 ms | 1.63 ms | 2.81× | 4.06× |
-| **10,000** | 2.95 ms | 2.15 ms | 20.86 ms | 7.06× | 9.70× |
-| **50,000** | 17.49 ms | 12.08 ms | 120.25 ms | 6.88× | 9.95× |
+| **100** | 0.04 ms | 0.04 ms | 0.10 ms | 2.68× | 2.63× |
+| **1,000** | 0.21 ms | 0.20 ms | 0.98 ms | 4.71× | 4.89× |
+| **10,000** | 1.39 ms | 1.49 ms | 9.93 ms | 7.14× | 6.67× |
+| **50,000** | 10.19 ms | 9.91 ms | 66.57 ms | 6.54× | 6.72× |
 
 > **Note:** rapidfuzz's `DamerauLevenshtein` uses Optimal String Alignment (OSA). fuzzgpu implements the **unrestricted** Lowrance-Wagner (1975) algorithm which allows non-adjacent transpositions. For example: `damerau("ca", "abc") == 2` (fuzzgpu) vs `3` (rapidfuzz OSA). Use `fuzzgpu.distance.OSA` for OSA-compatible semantics.
 
+### Jaro-Winkler Batch (p = 0.1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **100** | 0.02 ms | 0.01 ms | 0.02 ms | 0.87× | 1.14× |
+| **1,000** | 0.18 ms | 0.13 ms | 0.12 ms | 0.70× | 0.94× |
+| **10,000** | 1.01 ms | 0.83 ms | 0.97 ms | 0.96× | 1.18× |
+| **50,000** | 5.61 ms | 3.25 ms | 6.69 ms | 1.19× | 2.06× |
+
+### Needleman-Wunsch Affine Batch (match=1, mismatch=-1, gap_open=-2, gap_extend=-1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` |
+| :--- | :---: | :---: | :---: |
+| **100** | 0.07 ms | 0.05 ms | — |
+| **1,000** | 1.65 ms | 0.43 ms | — |
+| **10,000** | 12.49 ms | 3.91 ms | — |
+| **50,000** | 47.86 ms | 26.95 ms | — |
+
+> rapidfuzz has no Needleman-Wunsch API — no comparison available.
+
+### Levenshtein Cross-Product Matrix (`cdist`)
+| Matrix Size | Total Pairs | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | python-Levenshtein | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| **10 × 10** | 100 | 0.05 ms | 0.02 ms | 0.01 ms | 0.06 ms | 0.18× | 0.56× |
+| **50 × 50** | 2,500 | 0.58 ms | 0.11 ms | 0.09 ms | 2.17 ms | 0.16× | 0.81× |
+| **100 × 100** | 10,000 | 0.67 ms | 0.25 ms | 0.18 ms | 5.75 ms | 0.27× | 0.70× |
+| **200 × 200** | 40,000 | 1.19 ms | 0.81 ms | 0.61 ms | 22.31 ms | 0.51× | 0.75× |
+
 ---
 
 ## Installation
@@ -147,7 +222,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.1.6"
+fuzzgpu-core = "0.1.8"
 ```
 
 ---
@@ -243,8 +318,8 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.6"                                        # GPU + CPU fallback
-# fuzzgpu-core = { version = "0.1.6", default-features = false } # CPU-only
+fuzzgpu-core = "0.1.8"                                        # GPU + CPU fallback
+# fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 
 ```rust

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/README.md

@@ -8,7 +8,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.1.6-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.8-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)
@@ -31,34 +31,82 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.1.6
+## What's New in v0.1.8
+
+### Production hardening
+- **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
+  `GpuJaroKernel`, `GpuNeedlemanAffineKernel`, `GpuDamerauKernel`) previously called
+  `.unwrap()` on `OnceLock::get()` after initialization, which could panic the Python
+  interpreter under rare concurrent races. Replaced with `.ok_or_else(...)` returning
+  a proper `FuzzGpuError::NoDevice`.
+- **`debug_assert!` → real release guards** — `MyersPattern::new`, `jaro_bitpar`, `jaro_4way`
+  were guarded only by `debug_assert!`. In release builds, calling them with inputs outside
+  their contract (non-ASCII or > 64 bytes) would silently produce wrong results. Promoted to
+  proper `assert!` with descriptive messages that surface immediately in both debug and release.
+
+### New API surface
+- **`fuzz.cdist`** — pairwise score matrix, mirrors `rapidfuzz.fuzz.cdist`. Delegates to
+  `process.cdist` with `ratio` as the default scorer.
+- **`DamerauLevenshtein.editops` / `.opcodes`** — full Lowrance-Wagner traceback returning
+  `Editops` / `Opcodes` (insert/delete/replace), completing parity with rapidfuzz's alignment
+  API for this module.
+- **`fuzz.__all__`** now includes `partial_ratio_alignment` and `cdist` (were missing).
+
+### API correctness fixes
+- **`Jaro.similarity` / `JaroWinkler.similarity` `score_cutoff`** — changed default from
+  `0.0` to `None`, matching rapidfuzz's semantics (`0.0` treated scores of exactly 0.0 as
+  filtered, which was wrong).
+- **`ratio_batch(workers=)`** — was silently ignored (`del workers`). Now wires up a
+  `ThreadPoolExecutor` for the processor path; the no-processor path continues to use Rayon
+  internally (ignoring `workers` is correct there — Rayon already uses all cores).
+- **`process.cdist` fast path** — rewrote to use `fuzz_ratio_batch` row-by-row (each row
+  runs under Rayon across all cores) instead of a dead `raw = _native.fuzz_ratio_batch`
+  assignment followed by the same loop. Removed the dead `raw:` type-hint-only line.
+- **`process.cdist` silent swallow** — `except Exception: pass` replaced with
+  `warnings.warn(...)` so unexpected fast-path failures are visible instead of silently
+  producing slow results.
+
+### Includes all v0.1.7 fixes
+All fixes from v0.1.7 are included — see the v0.1.7 changelog below.
+
+---
+
+<details>
+<summary><b>Previous (v0.1.7)</b></summary>
+
+### Bug fixes (Windows DX12 / Jaro shader)
+- **Jaro GPU shader FXC crash fixed** — `jaro.wgsl` and `jaro_matrix.wgsl` used dynamic vector
+  component writes (`v[j >> 5u] = ...`) in `bit_set()`. Fixed by rewriting `bit_set` with
+  `select()`-based static construction (Vulkan, Metal, DX12 all compile identically).
+
+### Bug fixes (arity mismatch — wasm & fuzz crates)
+- **`fuzzgpu-wasm`** and **`fuzzgpu-fuzz`** — 4 × `E0061` arity mismatch for
+  `partial_ratio`/`token_sort_ratio`/`token_set_ratio`/`wratio`. Fixed by passing `0.0`
+  as the cutoff.
+
+</details>
+
+<details>
+<summary><b>Previous (v0.1.6)</b></summary>
 
 ### Drop-in rapidfuzz parity (Python)
 The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-pair differential harness across `ratio`, `partial_ratio`, `token_sort_ratio`, `token_set_ratio`, `token_ratio`, `WRatio`, `QRatio`, `partial_token_*`, `jaro`, `jaro_winkler`, `levenshtein`, `indel`, `hamming`, `osa` — **0 mismatches**.
 
 ### Bug fixes (Rust core, float parity)
-- **`ratio` / `partial_ratio` cutoff imprecision** — port of rapidfuzz's load-bearing `NormSim_to_NormDist = min(1, 1 - cutoff/100 + 1e-5)` term. Without it, the branch-and-bound would silently reject ties at exact cutoffs (e.g. `partial_ratio("park", "ba", score_cutoff=50.0)` returned `0` instead of `50`).
-- **`ratio` score formula** — switched from `((len-dist)/len)*100` to `(1 - dist/len)*100` to match rapidfuzz C++'s exact ulp order (`indel_normalized_similarity * 100`).
+- **`ratio` / `partial_ratio` cutoff imprecision** — port of rapidfuzz's load-bearing `NormSim_to_NormDist = min(1, 1 - cutoff/100 + 1e-5)` term.
+- **`ratio` score formula** — switched from `((len-dist)/len)*100` to `(1 - dist/len)*100` to match rapidfuzz C++'s exact ulp order.
 
 ### New features (Python distance layer)
-- **`Editops` / `Opcodes` / `Editop` / `Opcode` / `MatchingBlock` / `ScoreAlignment`** classes (rapidfuzz-compatible list-/tuple-likes with `as_list`, `as_opcodes`, `as_editops`, `as_matching_blocks`, `apply`, `inverse`, `remove_subsequence`, `from_*`).
-- **`Levenshtein.editops` / `.opcodes`** — exact Myers bit-parallel port with `common_affix` (suffix measured on post-prefix slice, matching rapidfuzz).
-- **`LCSseq`** module — Myers LCS bit-parallel matrix + editops/opcodes (delete-checked-first traceback).
-- **`Prefix`** and **`Postfix`** modules with the C++ `1 - dist/maximum` ulp order.
-- **`Hamming.editops` / `.opcodes`** — replace-per-mismatch + padding delete/insert model.
-- **`Indel.editops` / `.opcodes`** — delegates to `LCSseq` (matching rapidfuzz C++).
-- **`fuzz.partial_ratio_alignment`** now returns `ScoreAlignment(score, src_start, src_end, dest_start, dest_end)` — drop-in compatible with rapidfuzz.
-- **`process.extract` / `extractOne` / `cdist`** default to `WRatio` (matches rapidfuzz 3.14.5).
-- **`token_ratio` / `partial_token_ratio`** exposed at top level (`fuzzgpu.token_ratio`, `fuzzgpu.partial_token_ratio`).
-- All alignment types re-exported at the package root (`fuzzgpu.Editop`, `fuzzgpu.Editops`, etc.).
-
-### Type stubs
-- `__init__.pyi`, `fuzz.pyi`, `process.pyi`, `distance/__init__.pyi` updated for the new APIs.
+- **`Editops` / `Opcodes` / `Editop` / `Opcode` / `MatchingBlock` / `ScoreAlignment`** classes (rapidfuzz-compatible).
+- **`Levenshtein.editops` / `.opcodes`**, **`LCSseq`**, **`Prefix`**, **`Postfix`**, **`Hamming.editops`**, **`Indel.editops`** modules.
+- **`fuzz.partial_ratio_alignment`** returns `ScoreAlignment` (rapidfuzz-compatible).
+- **`process.extract` / `extractOne` / `cdist`** default to `WRatio`.
+- All alignment types re-exported at the package root.
 
----
+</details>
 
 <details>
-<summary><b>Previous (v0.1.5</b</summary>
+<summary><b>Previous (v0.1.5)</b></summary>
 
 ### Bug fixes
 - **Damerau-Levenshtein safety gate** now fires in release builds (`assert!` not `debug_assert!`) — non-ASCII inputs no longer silently produce wrong distances in production wheels
@@ -87,26 +135,53 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 ## Benchmark Results
 
 *Hardware: Intel(R) Iris(R) Xe Graphics (Vulkan) + Intel Core i7 (Rayon uses all cores)*
-*Versions: fuzzgpu 0.1.6 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Versions: fuzzgpu 0.1.8 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
 *Median of 7 runs after warmup. Reproduce: `python benchmarks/bench_compare.py`*
 
 ### Levenshtein Batch (1 query × N candidates, 10-char strings)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **100** | 0.12 ms | 0.01 ms | 0.03 ms | 0.25× | 2.21× |
-| **1,000** | 0.83 ms | 0.09 ms | 0.15 ms | 0.18× | 1.67× |
-| **10,000** | 2.60 ms | 0.87 ms | 1.47 ms | 0.57× | 1.68× |
-| **50,000** | 9.92 ms | 5.04 ms | 6.38 ms | 0.64× | 1.27× |
+| **100** | 0.04 ms | 0.00 ms | 0.01 ms | 0.24× | 1.90× |
+| **1,000** | 0.50 ms | 0.04 ms | 0.07 ms | 0.13× | 1.89× |
+| **10,000** | 1.53 ms | 0.40 ms | 0.64 ms | 0.42× | 1.61× |
+| **50,000** | 6.87 ms | 3.36 ms | 4.46 ms | 0.65× | 1.33× |
 
 ### Damerau-Levenshtein Batch (unrestricted Lowrance-Wagner)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **1,000** | 0.58 ms | 0.40 ms | 1.63 ms | 2.81× | 4.06× |
-| **10,000** | 2.95 ms | 2.15 ms | 20.86 ms | 7.06× | 9.70× |
-| **50,000** | 17.49 ms | 12.08 ms | 120.25 ms | 6.88× | 9.95× |
+| **100** | 0.04 ms | 0.04 ms | 0.10 ms | 2.68× | 2.63× |
+| **1,000** | 0.21 ms | 0.20 ms | 0.98 ms | 4.71× | 4.89× |
+| **10,000** | 1.39 ms | 1.49 ms | 9.93 ms | 7.14× | 6.67× |
+| **50,000** | 10.19 ms | 9.91 ms | 66.57 ms | 6.54× | 6.72× |
 
 > **Note:** rapidfuzz's `DamerauLevenshtein` uses Optimal String Alignment (OSA). fuzzgpu implements the **unrestricted** Lowrance-Wagner (1975) algorithm which allows non-adjacent transpositions. For example: `damerau("ca", "abc") == 2` (fuzzgpu) vs `3` (rapidfuzz OSA). Use `fuzzgpu.distance.OSA` for OSA-compatible semantics.
 
+### Jaro-Winkler Batch (p = 0.1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **100** | 0.02 ms | 0.01 ms | 0.02 ms | 0.87× | 1.14× |
+| **1,000** | 0.18 ms | 0.13 ms | 0.12 ms | 0.70× | 0.94× |
+| **10,000** | 1.01 ms | 0.83 ms | 0.97 ms | 0.96× | 1.18× |
+| **50,000** | 5.61 ms | 3.25 ms | 6.69 ms | 1.19× | 2.06× |
+
+### Needleman-Wunsch Affine Batch (match=1, mismatch=-1, gap_open=-2, gap_extend=-1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` |
+| :--- | :---: | :---: | :---: |
+| **100** | 0.07 ms | 0.05 ms | — |
+| **1,000** | 1.65 ms | 0.43 ms | — |
+| **10,000** | 12.49 ms | 3.91 ms | — |
+| **50,000** | 47.86 ms | 26.95 ms | — |
+
+> rapidfuzz has no Needleman-Wunsch API — no comparison available.
+
+### Levenshtein Cross-Product Matrix (`cdist`)
+| Matrix Size | Total Pairs | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | python-Levenshtein | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| **10 × 10** | 100 | 0.05 ms | 0.02 ms | 0.01 ms | 0.06 ms | 0.18× | 0.56× |
+| **50 × 50** | 2,500 | 0.58 ms | 0.11 ms | 0.09 ms | 2.17 ms | 0.16× | 0.81× |
+| **100 × 100** | 10,000 | 0.67 ms | 0.25 ms | 0.18 ms | 5.75 ms | 0.27× | 0.70× |
+| **200 × 200** | 40,000 | 1.19 ms | 0.81 ms | 0.61 ms | 22.31 ms | 0.51× | 0.75× |
+
 ---
 
 ## Installation
@@ -118,7 +193,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.1.6"
+fuzzgpu-core = "0.1.8"
 ```
 
 ---
@@ -214,8 +289,8 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.6"                                        # GPU + CPU fallback
-# fuzzgpu-core = { version = "0.1.6", default-features = false } # CPU-only
+fuzzgpu-core = "0.1.8"                                        # GPU + CPU fallback
+# fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 
 ```rust

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/Cargo.toml

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

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/damerau.rs

@@ -234,7 +234,9 @@ pub mod gpu_ext {
             let engine = GpuEngine::get()?;
             let kernel = Self::new_inner(engine)?;
             let _ = GLOBAL_GPU_DAMERAU_KERNEL.set(kernel);
-            Ok(GLOBAL_GPU_DAMERAU_KERNEL.get().unwrap())
+            GLOBAL_GPU_DAMERAU_KERNEL.get().ok_or_else(|| FuzzGpuError::NoDevice(
+                "Damerau kernel unexpectedly absent after init".into()
+            ))
         }
 
         fn new_inner(engine: std::sync::Arc<GpuEngine>) -> Result<Self> {

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/jaro.rs

@@ -357,7 +357,9 @@ pub mod gpu_ext {
             let engine = GpuEngine::get()?;
             let kernel = Self::new_inner(engine)?;
             let _ = GLOBAL_GPU_JARO_KERNEL.set(kernel);
-            Ok(GLOBAL_GPU_JARO_KERNEL.get().unwrap())
+            GLOBAL_GPU_JARO_KERNEL.get().ok_or_else(|| FuzzGpuError::NoDevice(
+                "Jaro kernel unexpectedly absent after init".into()
+            ))
         }
 
         fn new_inner(engine: std::sync::Arc<GpuEngine>) -> Result<Self> {

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/levenshtein.rs

@@ -246,8 +246,12 @@ pub mod gpu_ext {
             if let Some(k) = GLOBAL_GPU_KERNEL.get() { return Ok(k); }
             let engine = GpuEngine::get()?;
             let kernel = Self::new_inner(engine)?;
+            // A concurrent caller may have won the race and set it already;
+            // either way `get()` now returns `Some` — no unwrap needed.
             let _ = GLOBAL_GPU_KERNEL.set(kernel);
-            Ok(GLOBAL_GPU_KERNEL.get().unwrap())
+            GLOBAL_GPU_KERNEL.get().ok_or_else(|| FuzzGpuError::NoDevice(
+                "Levenshtein kernel unexpectedly absent after init".into()
+            ))
         }
 
         fn new_inner(engine: std::sync::Arc<GpuEngine>) -> Result<Self> {

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/needleman.rs

@@ -218,7 +218,9 @@ pub mod gpu_ext {
             let engine = GpuEngine::get()?;
             let kernel = Self::new_inner(engine)?;
             let _ = GLOBAL_GPU_KERNEL.set(kernel);
-            Ok(GLOBAL_GPU_KERNEL.get().unwrap())
+            GLOBAL_GPU_KERNEL.get().ok_or_else(|| FuzzGpuError::NoDevice(
+                "Needleman kernel unexpectedly absent after init".into()
+            ))
         }
 
         fn new_inner(engine: std::sync::Arc<GpuEngine>) -> Result<Self> {

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/shaders/jaro.wgsl

@@ -51,10 +51,19 @@ fn bit_test(mb: vec4<u32>, j: u32) -> bool {
 }
 
 // Return the bitmap with bit j set.
+// Uses select() instead of dynamic vector l-value indexing (v[expr] = ...)
+// because FXC (DX12 HLSL compiler) does not support dynamic vector component
+// writes — it cannot emit a register-indexed store for a non-constant index
+// and fails with X3550/X3511 when it tries to unroll around it.
 fn bit_set(mb: vec4<u32>, j: u32) -> vec4<u32> {
-    var v = mb;
-    v[j >> 5u] = v[j >> 5u] | (1u << (j & 31u));
-    return v;
+    let word = j >> 5u;
+    let bit  = 1u << (j & 31u);
+    return vec4<u32>(
+        mb.x | select(0u, bit, word == 0u),
+        mb.y | select(0u, bit, word == 1u),
+        mb.z | select(0u, bit, word == 2u),
+        mb.w | select(0u, bit, word == 3u),
+    );
 }
 
 @compute @workgroup_size(64)

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/shaders/jaro_matrix.wgsl

@@ -25,10 +25,20 @@ fn bit_test(mb: vec4<u32>, j: u32) -> bool {
     return ((mb[j >> 5u] >> (j & 31u)) & 1u) != 0u;
 }
 
+// Return the bitmap with bit j set.
+// Uses select() instead of dynamic vector l-value indexing (v[expr] = ...)
+// because FXC (DX12 HLSL compiler) does not support dynamic vector component
+// writes — it cannot emit a register-indexed store for a non-constant index
+// and fails with X3550/X3511 when it tries to unroll around it.
 fn bit_set(mb: vec4<u32>, j: u32) -> vec4<u32> {
-    var v = mb;
-    v[j >> 5u] = v[j >> 5u] | (1u << (j & 31u));
-    return v;
+    let word = j >> 5u;
+    let bit  = 1u << (j & 31u);
+    return vec4<u32>(
+        mb.x | select(0u, bit, word == 0u),
+        mb.y | select(0u, bit, word == 1u),
+        mb.z | select(0u, bit, word == 2u),
+        mb.w | select(0u, bit, word == 3u),
+    );
 }
 
 @compute @workgroup_size(16, 16)

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-core/src/simd.rs

@@ -110,7 +110,11 @@ pub(crate) struct MyersPattern {
 impl MyersPattern {
     /// Build pattern state. `pattern` must be non-empty ASCII ≤ 64 bytes.
     pub(crate) fn new(pattern: &[u8]) -> Self {
-        debug_assert!(!pattern.is_empty() && pattern.len() <= 64 && pattern.is_ascii());
+        assert!(
+            !pattern.is_empty() && pattern.len() <= 64 && pattern.is_ascii(),
+            "MyersPattern: pattern must be non-empty ASCII ≤ 64 bytes (got {} bytes, ascii={})",
+            pattern.len(), pattern.is_ascii()
+        );
         let mut peq = [0u64; 256];
         for (j, &ch) in pattern.iter().enumerate() {
             peq[ch as usize] |= 1u64 << j;
@@ -429,7 +433,8 @@ pub(crate) unsafe fn levenshtein_myers_2way_neon(pat: &MyersPattern, texts: [&[u
 
 /// 4-way kernel over a prebuilt pattern (see [`MyersPattern`]).
 pub(crate) fn levenshtein_myers_4way_pat(pat: &MyersPattern, texts: [&[u8]; 4]) -> [u32; 4] {
-    debug_assert!(texts.iter().all(|t| t.is_ascii()));
+    debug_assert!(texts.iter().all(|t| t.is_ascii()),
+        "levenshtein_myers_4way_pat: all text inputs must be ASCII");
     #[cfg(target_arch = "x86_64")]
     {
         if avx2_available() {
@@ -442,7 +447,8 @@ pub(crate) fn levenshtein_myers_4way_pat(pat: &MyersPattern, texts: [&[u8]; 4])
 
 /// Scalar Myers over a prebuilt pattern (tail/fallback path of the batch).
 pub(crate) fn levenshtein_myers_pattern(pat: &MyersPattern, text: &[u8]) -> u32 {
-    debug_assert!(text.is_ascii());
+    debug_assert!(text.is_ascii(),
+        "levenshtein_myers_pattern: text must be ASCII");
     let MyersPattern { peq, m, mask, last_bit } = pat;
     let mut pv: u64 = *mask;
     let mut mv: u64 = 0;
@@ -624,8 +630,11 @@ unsafe fn levenshtein_myers_4way_avx2(pat: &MyersPattern, texts: [&[u8]; 4]) ->
 /// walk as the reference. ASCII bytes, both inputs ≤ 64 (the position masks
 /// must fit one u64).
 pub fn jaro_bitpar(a: &[u8], b: &[u8]) -> f64 {
-    debug_assert!(a.len() <= 64 && b.len() <= 64);
-    debug_assert!(a.is_ascii() && b.is_ascii());
+    assert!(
+        a.len() <= 64 && b.len() <= 64 && a.is_ascii() && b.is_ascii(),
+        "jaro_bitpar: inputs must be ASCII ≤ 64 bytes (got a={} bytes ascii={}, b={} bytes ascii={})",
+        a.len(), a.is_ascii(), b.len(), b.is_ascii()
+    );
     let (m, n) = (a.len(), b.len());
     if m == 0 && n == 0 {
         return 1.0;
@@ -703,7 +712,11 @@ pub fn jaro_bitpar(a: &[u8], b: &[u8]) -> f64 {
 /// the Iris Xe-class CPUs this targets). Transpositions and scoring run in a
 /// short scalar tail per lane.
 pub fn jaro_4way(a: &[u8], texts: [&[u8]; 4]) -> [f64; 4] {
-    debug_assert!(a.len() <= 64 && a.is_ascii());
+    assert!(
+        a.len() <= 64 && a.is_ascii(),
+        "jaro_4way: first argument must be ASCII ≤ 64 bytes (got {} bytes, ascii={})",
+        a.len(), a.is_ascii()
+    );
     debug_assert!(texts.iter().all(|t| t.len() <= 64 && t.is_ascii()));
     #[cfg(target_arch = "x86_64")]
     {

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-python"
-version = "0.1.6"
+version = "0.1.8"
 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.1.6", default-features = false }
+fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.1.8", default-features = false }
 pyo3 = { workspace = true, features = ["abi3-py310"] }
 numpy = "0.23"
 pollster = { workspace = true }

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-wasm/Cargo.toml

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

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/crates/fuzzgpu-wasm/src/lib.rs

@@ -57,22 +57,22 @@ pub fn ratio(a: &str, b: &str) -> f64 {
 
 #[wasm_bindgen]
 pub fn partial_ratio(a: &str, b: &str) -> f64 {
-    fuzzgpu_core::partial_ratio(a, b)
+    fuzzgpu_core::partial_ratio(a, b, 0.0)
 }
 
 #[wasm_bindgen]
 pub fn token_sort_ratio(a: &str, b: &str) -> f64 {
-    fuzzgpu_core::token_sort_ratio(a, b)
+    fuzzgpu_core::token_sort_ratio(a, b, 0.0)
 }
 
 #[wasm_bindgen]
 pub fn token_set_ratio(a: &str, b: &str) -> f64 {
-    fuzzgpu_core::token_set_ratio(a, b)
+    fuzzgpu_core::token_set_ratio(a, b, 0.0)
 }
 
 #[wasm_bindgen]
 pub fn wratio(a: &str, b: &str) -> f64 {
-    fuzzgpu_core::wratio(a, b)
+    fuzzgpu_core::wratio(a, b, 0.0)
 }
 
 #[wasm_bindgen]

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/pyproject.toml

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

fuzzgpu-0.1.8/python/fuzzgpu/distance/DamerauLevenshtein.py

@@ -0,0 +1,145 @@
+"""rapidfuzz.distance.DamerauLevenshtein-compatible module.
+
+NOTE: This module implements the **unrestricted** Lowrance-Wagner (1975)
+algorithm which allows non-adjacent transpositions.  rapidfuzz's
+DamerauLevenshtein uses Optimal String Alignment (OSA) which forbids them.
+For OSA-compatible semantics use fuzzgpu.distance.OSA.
+Example difference: distance("ca", "abc") == 2 here (unrestricted),
+== 3 in rapidfuzz's OSA-based DamerauLevenshtein.
+"""
+from .. import fuzzgpu as _native
+from ._common import Editop, Editops, cutoff_distance, normalized_distance as _normalized
+
+
+def distance(s1, s2, *, processor=None, score_cutoff=None, score_hint=None):
+    del score_hint
+    if processor:
+        s1, s2 = processor(s1), processor(s2)
+    return cutoff_distance(_native.damerau_levenshtein_distance(s1, s2), score_cutoff)
+
+
+def similarity(s1, s2, *, 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 = maximum - distance(s1, s2)
+    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):
+    del score_hint
+    if processor:
+        s1, s2 = processor(s1), processor(s2)
+    value = _normalized(distance(s1, s2), max(len(s1), len(s2)))
+    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):
+    del score_hint
+    if processor:
+        s1, s2 = processor(s1), processor(s2)
+    value = 1.0 - _normalized(distance(s1, s2), max(len(s1), len(s2)))
+    return value if score_cutoff is None or value >= score_cutoff else 0.0
+
+
+# ── Alignment helpers ─────────────────────────────────────────────────────────
+
+def _damerau_matrix(s1, s2):
+    """Full Lowrance-Wagner DP matrix for traceback.
+
+    Returns the filled (m+2) × (n+2) cost matrix as a list of lists so the
+    traceback can reconstruct the edit path.  The layout matches the standard
+    Lowrance-Wagner (1975) formulation with the da[] last-seen-position table.
+    """
+    m, n = len(s1), len(s2)
+    INF = m + n + 1
+
+    # d[i][j]: cost to turn s1[:i] into s2[:j]
+    d = [[0] * (n + 2) for _ in range(m + 2)]
+    d[0][0] = INF
+    for i in range(m + 1):
+        d[i + 1][0] = INF
+        d[i + 1][1] = i
+    for j in range(n + 1):
+        d[0][j + 1] = INF
+        d[1][j + 1] = j
+
+    # da[c] = last row where character c was seen in s1 (1-indexed)
+    da = {}
+
+    for i in range(1, m + 1):
+        db = 0  # last column where s1[i-1] was seen in s2 (1-indexed)
+        for j in range(1, n + 1):
+            i1 = da.get(s2[j - 1], 0)
+            j1 = db
+            cost = 0 if s1[i - 1] == s2[j - 1] else 1
+            if cost == 0:
+                db = j
+            d[i + 1][j + 1] = min(
+                d[i][j] + cost,           # substitute / match
+                d[i + 1][j] + 1,          # insert
+                d[i][j + 1] + 1,          # delete
+                d[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1),  # transpose
+            )
+        da[s1[i - 1]] = i
+
+    return d
+
+
+def editops(s1, s2, *, processor=None, score_hint=None):
+    """Return Editops describing how to turn s1 into s2 (Lowrance-Wagner).
+
+    The returned edit sequence uses only insert/delete/replace operations —
+    transpositions are decomposed into the minimum-cost sequence of those
+    three primitive operations, which is how rapidfuzz represents them too.
+    """
+    del score_hint
+    if processor:
+        s1, s2 = processor(s1), processor(s2)
+
+    m, n = len(s1), len(s2)
+    result = Editops([], 0, 0)
+    result._src_len = m
+    result._dest_len = n
+
+    if s1 == s2:
+        return result
+
+    d = _damerau_matrix(s1, s2)
+
+    # Traceback from d[m+1][n+1] (1-indexed DP, offset by 1 for the INF border)
+    ops = []
+    i, j = m, n
+    while i > 0 or j > 0:
+        if i > 0 and j > 0:
+            cost = 0 if s1[i - 1] == s2[j - 1] else 1
+            if d[i + 1][j + 1] == d[i][j] + cost:
+                if cost:
+                    ops.append(Editop("replace", i - 1, j - 1))
+                i -= 1
+                j -= 1
+                continue
+        if j > 0 and d[i + 1][j + 1] == d[i + 1][j] + 1:
+            ops.append(Editop("insert", i, j - 1))
+            j -= 1
+        elif i > 0 and d[i + 1][j + 1] == d[i][j + 1] + 1:
+            ops.append(Editop("delete", i - 1, j))
+            i -= 1
+        else:
+            # Transposition or boundary — fall back to delete+insert decomposition
+            if i > 0:
+                ops.append(Editop("delete", i - 1, j))
+                i -= 1
+            else:
+                ops.append(Editop("insert", i, j - 1))
+                j -= 1
+
+    ops.reverse()
+    result._editops = ops
+    return result
+
+
+def opcodes(s1, s2, *, processor=None, score_hint=None):
+    """Return Opcodes describing how to turn s1 into s2."""
+    return editops(s1, s2, processor=processor, score_hint=score_hint).as_opcodes()

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/python/fuzzgpu/distance/Jaro.py

@@ -2,11 +2,11 @@
 from .. import fuzzgpu as _native
 
 
-def similarity(s1, s2, *, processor=None, score_cutoff=0.0):
+def similarity(s1, s2, *, processor=None, score_cutoff=None):
     if processor:
         s1, s2 = processor(s1), processor(s2)
     value = _native.jaro_similarity(s1, s2)
-    return value if value >= score_cutoff else 0.0
+    return value if score_cutoff is None or value >= score_cutoff else 0.0
 
 
 def distance(s1, s2, *, processor=None, score_cutoff=None):
@@ -16,7 +16,7 @@ def distance(s1, s2, *, processor=None, score_cutoff=None):
     return value if score_cutoff is None or value <= score_cutoff else 1.0
 
 
-def normalized_similarity(s1, s2, *, processor=None, score_cutoff=0.0):
+def normalized_similarity(s1, s2, *, processor=None, score_cutoff=None):
     return similarity(s1, s2, processor=processor, score_cutoff=score_cutoff)
 
 

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/python/fuzzgpu/distance/JaroWinkler.py

@@ -2,11 +2,11 @@
 from .. import fuzzgpu as _native
 
 
-def similarity(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=0.0):
+def similarity(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=None):
     if processor:
         s1, s2 = processor(s1), processor(s2)
     value = _native.jaro_winkler_similarity(s1, s2, prefix_weight)
-    return value if value >= score_cutoff else 0.0
+    return value if score_cutoff is None or value >= score_cutoff else 0.0
 
 
 def distance(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=None):
@@ -16,7 +16,7 @@ def distance(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=None):
     return value if score_cutoff is None or value <= score_cutoff else 1.0
 
 
-def normalized_similarity(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=0.0):
+def normalized_similarity(s1, s2, *, prefix_weight=0.1, processor=None, score_cutoff=None):
     return similarity(s1, s2, prefix_weight=prefix_weight,
                       processor=processor, score_cutoff=score_cutoff)
 

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/python/fuzzgpu/fuzz.py

@@ -1,9 +1,22 @@
 """rapidfuzz-compatible fuzzy scorers backed by fuzzgpu's Rust extension."""
 
+import os
+
 from . import fuzzgpu as _native
 from .distance._common import ScoreAlignment
 
 
+def _worker_count(workers):
+    """Resolve the workers parameter to a concrete thread count."""
+    if workers is None or workers == 1:
+        return 1
+    if workers == -1:
+        return os.cpu_count() or 1
+    if isinstance(workers, int) and workers > 0:
+        return workers
+    raise ValueError("workers must be None, -1, or a positive integer")
+
+
 def _prepare(a, b, processor):
     if processor is not None:
         a, b = processor(a), processor(b)
@@ -81,11 +94,27 @@ wratio = WRatio
 
 
 def ratio_batch(query, candidates, *, processor=None, score_cutoff=0.0, workers=None):
-    del workers
+    """Compute ratio(query, c) for every c in candidates.
+
+    When no processor is given the computation runs inside Rust under Rayon
+    (all cores); ``workers`` is ignored in that case since Rayon already
+    parallelises across cores.  When a Python ``processor`` is supplied the
+    work runs in Python and ``workers`` controls the thread pool size
+    (``None``/``1`` = single-threaded, ``-1`` = all CPU cores).
+    """
     if processor is None:
         values = _native.fuzz_ratio_batch(query, candidates)
         return values if score_cutoff <= 0.0 else [_cutoff(v, score_cutoff) for v in values]
-    return [ratio(query, c, processor=processor, score_cutoff=score_cutoff) for c in candidates]
+    # processor path: honour workers
+    n = _worker_count(workers) if workers is not None and workers != 1 else 1
+    if n == 1:
+        return [ratio(query, c, processor=processor, score_cutoff=score_cutoff) for c in candidates]
+    from concurrent.futures import ThreadPoolExecutor
+    with ThreadPoolExecutor(max_workers=n) as pool:
+        return list(pool.map(
+            lambda c: ratio(query, c, processor=processor, score_cutoff=score_cutoff),
+            candidates
+        ))
 
 
 def extract(query, choices, score_cutoff=0.0, limit=5, *, scorer=ratio, processor=None,
@@ -108,10 +137,32 @@ extract_one = extractOne
 damerau_ratio = _native.damerau_ratio
 
 
+def cdist(queries, choices, *, scorer=None, processor=None, score_cutoff=None,
+          score_hint=None, score_multiplier=1, dtype=None, workers=None,
+          scorer_kwargs=None):
+    """Pairwise score matrix between all queries and all choices.
+
+    Delegates to ``process.cdist`` with ``scorer`` defaulting to
+    ``fuzz.ratio`` (matching rapidfuzz's ``fuzz.cdist``).
+    """
+    from .process import cdist as _cdist
+    return _cdist(
+        queries, choices,
+        scorer=scorer if scorer is not None else ratio,
+        processor=processor,
+        score_cutoff=score_cutoff,
+        score_hint=score_hint,
+        score_multiplier=score_multiplier,
+        dtype=dtype,
+        workers=workers,
+        scorer_kwargs=scorer_kwargs,
+    )
+
+
 __all__ = [
     "ratio", "partial_ratio", "partial_ratio_alignment",
     "token_sort_ratio", "token_set_ratio", "token_ratio",
     "partial_token_sort_ratio", "partial_token_set_ratio", "partial_token_ratio",
-    "QRatio", "WRatio", "wratio", "ratio_batch",
+    "QRatio", "WRatio", "wratio", "ratio_batch", "cdist",
     "extract", "extractOne", "extract_one", "damerau_ratio",
 ]

{fuzzgpu-0.1.6 → fuzzgpu-0.1.8}/python/fuzzgpu/process.py

@@ -175,8 +175,12 @@ def cdist(
     choices = list(choices)
 
     # ── Fast path: native ratio scorer, no per-string processor ──────────
-    # Route through the accelerated Rust matrix kernel.  The result is in
-    # 0–100 float, matching what the slow path would produce.
+    # Route through the accelerated Rust fuzz_ratio_batch for each query row.
+    # Each row call releases the GIL and runs under Rayon, so the Python loop
+    # here only pays per-query overhead — not per-cell. This is still correct
+    # behaviour for `workers`: Rayon uses all cores inside each row call, so
+    # `workers` is ignored at the Python level (it would just add Python thread
+    # overhead on top of Rayon's own parallelism).
     if (
         _is_native_ratio(scorer)
         and processor is None
@@ -185,15 +189,14 @@ def cdist(
     ):
         try:
             from . import fuzzgpu as _native
-            # Apply score_cutoff: cells below threshold become 0.0 (same
-            # behaviour as the per-cell slow path with score_cutoff set).
-            raw: list[list[float]] = _native.fuzz_ratio_batch  # type hint only
-            matrix: list[list[float]] = []
-            for q in queries:
-                row = _native.fuzz_ratio_batch(q, choices)
-                if score_cutoff is not None:
-                    row = [v if v >= score_cutoff else 0.0 for v in row]
-                matrix.append(row)
+            matrix: list[list[float]] = [
+                _native.fuzz_ratio_batch(q, choices) for q in queries
+            ]
+            if score_cutoff is not None:
+                matrix = [
+                    [v if v >= score_cutoff else 0.0 for v in row]
+                    for row in matrix
+                ]
             if dtype is not None:
                 try:
                     import numpy as np
@@ -201,9 +204,13 @@ def cdist(
                 except ImportError:
                     pass
             return matrix
-        except Exception:
-            # Fall through to the generic path on any unexpected error.
-            pass
+        except Exception as exc:
+            import warnings
+            warnings.warn(
+                f"fuzzgpu cdist fast path failed ({exc!r}), falling back to per-cell scorer",
+                RuntimeWarning,
+                stacklevel=2,
+            )
 
     # ── Generic path ─────────────────────────────────────────────────────
     def row(query):

fuzzgpu-0.1.6/python/fuzzgpu/distance/DamerauLevenshtein.py

@@ -1,43 +0,0 @@
-"""rapidfuzz.distance.DamerauLevenshtein-compatible module.
-
-NOTE: This module implements the **unrestricted** Lowrance-Wagner (1975)
-algorithm which allows non-adjacent transpositions.  rapidfuzz's
-DamerauLevenshtein uses Optimal String Alignment (OSA) which forbids them.
-For OSA-compatible semantics use fuzzgpu.distance.OSA.
-Example difference: distance("ca", "abc") == 2 here (unrestricted),
-== 3 in rapidfuzz's OSA-based DamerauLevenshtein.
-"""
-from .. import fuzzgpu as _native
-from ._common import cutoff_distance, normalized_distance as _normalized
-
-
-def distance(s1, s2, *, processor=None, score_cutoff=None, score_hint=None):
-    del score_hint
-    if processor:
-        s1, s2 = processor(s1), processor(s2)
-    return cutoff_distance(_native.damerau_levenshtein_distance(s1, s2), score_cutoff)
-
-
-def similarity(s1, s2, *, 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 = maximum - distance(s1, s2)
-    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):
-    del score_hint
-    if processor:
-        s1, s2 = processor(s1), processor(s2)
-    value = _normalized(distance(s1, s2), max(len(s1), len(s2)))
-    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):
-    del score_hint
-    if processor:
-        s1, s2 = processor(s1), processor(s2)
-    value = 1.0 - _normalized(distance(s1, s2), max(len(s1), len(s2)))
-    return value if score_cutoff is None or value >= score_cutoff else 0.0