fuzzgpu 0.1.2__tar.gz → 0.1.3__tar.gz

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/Cargo.lock

@@ -248,7 +248,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "bytemuck",
  "log",
@@ -260,7 +260,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "fuzzgpu-core",
  "pollster",

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.1.2
+Version: 0.1.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -13,6 +13,9 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Text Processing :: General
+Requires-Dist: pytest>=7.0 ; extra == 'test'
+Requires-Dist: pytest-benchmark ; extra == 'test'
+Provides-Extra: test
 License-File: LICENSE
 Summary: Hardware-accelerated fuzzy string matching & sequence alignment — cross-platform, no CUDA required
 Keywords: gpu,fuzzy,string-matching,levenshtein,damerau,jaro-winkler,needleman-wunsch,webgpu
@@ -35,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.1.2-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.3-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.75+-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)
@@ -100,7 +103,7 @@ pip install fuzzgpu
 ### Rust (Cargo.toml)
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.2"
+fuzzgpu-core = "0.1.3"
 ```
 
 ---

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/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.2-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.3-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.75+-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)
@@ -73,7 +73,7 @@ pip install fuzzgpu
 ### Rust (Cargo.toml)
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.2"
+fuzzgpu-core = "0.1.3"
 ```
 
 ---

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-core/Cargo.toml

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

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-core/src/damerau.rs

@@ -16,6 +16,7 @@ pub fn damerau_levenshtein_distance(a: &str, b: &str) -> u32 {
 }
 
 fn damerau_bytes(a: &[u8], b: &[u8]) -> u32 {
+    debug_assert!(a.is_ascii() && b.is_ascii(), "damerau_bytes requires ASCII inputs");
     let (m, n) = (a.len(), b.len());
     if m == 0 { return n as u32; }
     if n == 0 { return m as u32; }

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-core/src/gpu.rs

@@ -28,6 +28,7 @@ pub struct GpuEngine {
 
 static GLOBAL_ENGINE: OnceLock<Arc<GpuEngine>> = OnceLock::new();
 static CPU_ONLY_FLAG: AtomicBool = AtomicBool::new(false);
+static ENV_CPU_CHECK: OnceLock<bool> = OnceLock::new();
 
 #[derive(Debug, Clone)]
 pub struct GpuInfo {
@@ -41,17 +42,18 @@ impl GpuEngine {
         CPU_ONLY_FLAG.store(cpu_only, Ordering::SeqCst);
     }
 
-    /// Check whether CPU-only mode is active.
+    /// Check whether CPU-only mode is active (cached, zero syscall overhead in loops).
     pub fn is_cpu_only() -> bool {
         if CPU_ONLY_FLAG.load(Ordering::Relaxed) {
             return true;
         }
-        if let Ok(v) = std::env::var("FUZZGPU_USE_CPU") {
-            if v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes") {
-                return true;
+        *ENV_CPU_CHECK.get_or_init(|| {
+            if let Ok(v) = std::env::var("FUZZGPU_USE_CPU") {
+                v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes")
+            } else {
+                false
             }
-        }
-        false
+        })
     }
 
     /// Returns whether a GPU device is available and ready for compute.
@@ -65,7 +67,7 @@ impl GpuEngine {
     /// Get or lazily initialize the singleton GPU engine.
     pub fn get() -> Result<Arc<Self>> {
         if Self::is_cpu_only() {
-            return Err(FuzzGpuError::NoDevice("CPU-only mode is forced (FUZZGPU_USE_CPU)".into()));
+            return Err(FuzzGpuError::NoDevice("CPU-only mode is active (FUZZGPU_USE_CPU)".into()));
         }
 
         if let Some(engine) = GLOBAL_ENGINE.get() {
@@ -105,7 +107,7 @@ impl GpuEngine {
             backend: format!("{:?}", adapter_info.backend),
         };
 
-        // Query adapter limits dynamically rather than blindly hardcoding 128MB
+        // Query adapter limits dynamically rather than hardcoding static limits
         let adapter_limits = adapter.limits();
         let target_storage_size = (128 * 1024 * 1024).min(adapter_limits.max_storage_buffer_binding_size);
         let target_buffer_size = (128 * 1024 * 1024).min(adapter_limits.max_buffer_size);
@@ -113,7 +115,7 @@ impl GpuEngine {
         let required_limits = wgpu::Limits {
             max_storage_buffer_binding_size: target_storage_size,
             max_buffer_size: target_buffer_size,
-            max_compute_workgroup_storage_size: 16 * 1024.min(adapter_limits.max_compute_workgroup_storage_size),
+            max_compute_workgroup_storage_size: 16384.min(adapter_limits.max_compute_workgroup_storage_size),
             max_compute_invocations_per_workgroup: 256.min(adapter_limits.max_compute_invocations_per_workgroup),
             ..Default::default()
         };
@@ -121,31 +123,24 @@ impl GpuEngine {
         let (device, queue) = adapter
             .request_device(
                 &wgpu::DeviceDescriptor {
-                    label: Some("fuzzgpu"),
+                    label: Some("fuzzgpu device"),
                     required_features: wgpu::Features::empty(),
                     required_limits,
-                    memory_hints: wgpu::MemoryHints::Performance,
+                    memory_hints: Default::default(),
                 },
                 None,
             )
             .await
             .map_err(|e| FuzzGpuError::NoDevice(format!("Failed to create GPU device: {}", e)))?;
 
-        if std::env::var("FUZZGPU_DEBUG").is_ok() {
-            eprintln!(
-                "fuzzgpu: Initialized {} ({}) with max buffer size {} MB",
-                info.name,
-                info.backend,
-                target_buffer_size / (1024 * 1024)
-            );
-        }
-
-        Ok(Arc::new(Self {
+        let engine = Arc::new(Self {
             device,
             queue,
             info,
-            max_buffer_size: target_buffer_size,
+            max_buffer_size: target_buffer_size as u64,
             max_storage_buffer_binding_size: target_storage_size,
-        }))
+        });
+
+        Ok(engine)
     }
 }

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-core/src/needleman.rs

@@ -4,7 +4,8 @@ use rayon::prelude::*;
 ///
 /// Uses single-row DP + scalar diagonal for minimal memory.
 /// Supports both ASCII fast-path and full Unicode characters.
-pub fn needleman_wunsch(a: &str, b: &str, match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+/// All scores use `i64` with saturating arithmetic to prevent integer overflow on long sequences.
+pub fn needleman_wunsch(a: &str, b: &str, match_score: i64, mismatch_score: i64, gap_penalty: i64) -> i64 {
     if a.is_ascii() && b.is_ascii() {
         needleman_wunsch_bytes(a.as_bytes(), b.as_bytes(), match_score, mismatch_score, gap_penalty)
     } else {
@@ -14,29 +15,29 @@ pub fn needleman_wunsch(a: &str, b: &str, match_score: i32, mismatch_score: i32,
     }
 }
 
-fn needleman_wunsch_bytes(a: &[u8], b: &[u8], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+fn needleman_wunsch_bytes(a: &[u8], b: &[u8], match_score: i64, mismatch_score: i64, gap_penalty: i64) -> i64 {
     needleman_wunsch_slice(a, b, match_score, mismatch_score, gap_penalty)
 }
 
-fn needleman_wunsch_chars(a: &[char], b: &[char], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+fn needleman_wunsch_chars(a: &[char], b: &[char], match_score: i64, mismatch_score: i64, gap_penalty: i64) -> i64 {
     needleman_wunsch_slice(a, b, match_score, mismatch_score, gap_penalty)
 }
 
-fn needleman_wunsch_slice<T: PartialEq>(a: &[T], b: &[T], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+fn needleman_wunsch_slice<T: PartialEq>(a: &[T], b: &[T], match_score: i64, mismatch_score: i64, gap_penalty: i64) -> i64 {
     let (m, n) = (a.len(), b.len());
 
-    if m == 0 { return (n as i32).saturating_mul(gap_penalty); }
-    if n == 0 { return (m as i32).saturating_mul(gap_penalty); }
-    if a == b { return (m as i32).saturating_mul(match_score); }
+    if m == 0 { return (n as i64).saturating_mul(gap_penalty); }
+    if n == 0 { return (m as i64).saturating_mul(gap_penalty); }
+    if a == b { return (m as i64).saturating_mul(match_score); }
 
-    let mut row = vec![0i32; n + 1];
+    let mut row = vec![0i64; n + 1];
     for (j, item) in row.iter_mut().enumerate() {
-        *item = (j as i32).saturating_mul(gap_penalty);
+        *item = (j as i64).saturating_mul(gap_penalty);
     }
 
     for i in 1..=m {
         let mut prev_diag = row[0];
-        row[0] = (i as i32).saturating_mul(gap_penalty);
+        row[0] = (i as i64).saturating_mul(gap_penalty);
         let ai = &a[i - 1];
         for j in 1..=n {
             let old = row[j];
@@ -53,14 +54,14 @@ fn needleman_wunsch_slice<T: PartialEq>(a: &[T], b: &[T], match_score: i32, mism
 /// Batch Needleman-Wunsch with linear gap penalty.
 pub fn needleman_wunsch_batch(
     query: &str, candidates: &[&str],
-    match_score: i32, mismatch_score: i32, gap_penalty: i32,
-) -> Vec<i32> {
+    match_score: i64, mismatch_score: i64, gap_penalty: i64,
+) -> Vec<i64> {
     candidates.par_iter().map(|c| {
         needleman_wunsch(query, c, match_score, mismatch_score, gap_penalty)
     }).collect()
 }
 
-const NEG_INF: i32 = -1_000_000_000;
+const NEG_INF: i64 = -1_000_000_000_000_000_000;
 
 /// Needleman-Wunsch global alignment score with affine gap penalties (Gotoh 1982 algorithm).
 ///
@@ -68,11 +69,11 @@ const NEG_INF: i32 = -1_000_000_000;
 pub fn needleman_wunsch_affine(
     a: &str,
     b: &str,
-    match_score: i32,
-    mismatch_score: i32,
-    gap_open: i32,
-    gap_extend: i32,
-) -> i32 {
+    match_score: i64,
+    mismatch_score: i64,
+    gap_open: i64,
+    gap_extend: i64,
+) -> i64 {
     if a.is_ascii() && b.is_ascii() {
         needleman_wunsch_affine_slice(a.as_bytes(), b.as_bytes(), match_score, mismatch_score, gap_open, gap_extend)
     } else {
@@ -85,17 +86,17 @@ pub fn needleman_wunsch_affine(
 fn needleman_wunsch_affine_slice<T: PartialEq>(
     a: &[T],
     b: &[T],
-    match_score: i32,
-    mismatch_score: i32,
-    gap_open: i32,
-    gap_extend: i32,
-) -> i32 {
+    match_score: i64,
+    mismatch_score: i64,
+    gap_open: i64,
+    gap_extend: i64,
+) -> i64 {
     let (m, n) = (a.len(), b.len());
 
     if m == 0 && n == 0 { return 0; }
-    if m == 0 { return gap_open + (n as i32) * gap_extend; }
-    if n == 0 { return gap_open + (m as i32) * gap_extend; }
-    if a == b { return (m as i32) * match_score; }
+    if m == 0 { return gap_open.saturating_add((n as i64).saturating_mul(gap_extend)); }
+    if n == 0 { return gap_open.saturating_add((m as i64).saturating_mul(gap_extend)); }
+    if a == b { return (m as i64).saturating_mul(match_score); }
 
     let mut m_row = vec![NEG_INF; n + 1];
     let mut ix_row = vec![NEG_INF; n + 1];
@@ -103,7 +104,7 @@ fn needleman_wunsch_affine_slice<T: PartialEq>(
 
     m_row[0] = 0;
     for j in 1..=n {
-        let gap_cost = gap_open + (j as i32) * gap_extend;
+        let gap_cost = gap_open.saturating_add((j as i64).saturating_mul(gap_extend));
         iy_row[j] = gap_cost;
         m_row[j] = gap_cost;
     }
@@ -113,7 +114,7 @@ fn needleman_wunsch_affine_slice<T: PartialEq>(
         let mut prev_ix_diag = ix_row[0];
         let mut prev_iy_diag = iy_row[0];
 
-        let gap_cost_i = gap_open + (i as i32) * gap_extend;
+        let gap_cost_i = gap_open.saturating_add((i as i64).saturating_mul(gap_extend));
         ix_row[0] = gap_cost_i;
         m_row[0] = gap_cost_i;
         iy_row[0] = NEG_INF;
@@ -125,10 +126,14 @@ fn needleman_wunsch_affine_slice<T: PartialEq>(
             let sub_score = if ai == bj { match_score } else { mismatch_score };
 
             let prev_diag_best = prev_m_diag.max(prev_ix_diag).max(prev_iy_diag);
-            let new_m = prev_diag_best + sub_score;
+            let new_m = prev_diag_best.saturating_add(sub_score);
 
-            let new_ix = (ix_row[j] + gap_extend).max(m_row[j] + gap_open + gap_extend).max(iy_row[j] + gap_open + gap_extend);
-            let new_iy = (iy_row[j - 1] + gap_extend).max(m_row[j - 1] + gap_open + gap_extend).max(ix_row[j - 1] + gap_open + gap_extend);
+            let new_ix = (ix_row[j].saturating_add(gap_extend))
+                .max(m_row[j].saturating_add(gap_open).saturating_add(gap_extend))
+                .max(iy_row[j].saturating_add(gap_open).saturating_add(gap_extend));
+            let new_iy = (iy_row[j - 1].saturating_add(gap_extend))
+                .max(m_row[j - 1].saturating_add(gap_open).saturating_add(gap_extend))
+                .max(ix_row[j - 1].saturating_add(gap_open).saturating_add(gap_extend));
 
             prev_m_diag = m_row[j];
             prev_ix_diag = ix_row[j];
@@ -147,11 +152,11 @@ fn needleman_wunsch_affine_slice<T: PartialEq>(
 pub fn needleman_wunsch_affine_batch(
     query: &str,
     candidates: &[&str],
-    match_score: i32,
-    mismatch_score: i32,
-    gap_open: i32,
-    gap_extend: i32,
-) -> Vec<i32> {
+    match_score: i64,
+    mismatch_score: i64,
+    gap_open: i64,
+    gap_extend: i64,
+) -> Vec<i64> {
     candidates.par_iter().map(|c| {
         needleman_wunsch_affine(query, c, match_score, mismatch_score, gap_open, gap_extend)
     }).collect()

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-core/src/simd.rs

@@ -106,23 +106,23 @@ fn levenshtein_dp_optimized(a: &[u8], b: &[u8]) -> u32 {
 
 /// Optimized Needleman-Wunsch with cache-friendly loop tiling.
 /// (Renamed from `needleman_wunsch_simd` — no actual SIMD intrinsics are used.)
-pub fn needleman_wunsch_striped(a: &[u8], b: &[u8], match_score: i32, mismatch_score: i32, gap_penalty: i32) -> i32 {
+pub fn needleman_wunsch_striped(a: &[u8], b: &[u8], match_score: i64, mismatch_score: i64, gap_penalty: i64) -> i64 {
     let (m, n) = (a.len(), b.len());
-    if m == 0 { return (n as i32) * gap_penalty; }
-    if n == 0 { return (m as i32) * gap_penalty; }
+    if m == 0 { return (n as i64).saturating_mul(gap_penalty); }
+    if n == 0 { return (m as i64).saturating_mul(gap_penalty); }
 
     // Fast path: identical strings.
-    if a == b { return (m as i32) * match_score; }
+    if a == b { return (m as i64).saturating_mul(match_score); }
 
     // Single-row + diagonal optimization.
-    let mut row = vec![0i32; n + 1];
+    let mut row = vec![0i64; n + 1];
     for (j, item) in row.iter_mut().enumerate() {
-        *item = (j as i32) * gap_penalty;
+        *item = (j as i64).saturating_mul(gap_penalty);
     }
 
     for i in 1..=m {
         let mut prev_diag = row[0];
-        row[0] = (i as i32) * gap_penalty;
+        row[0] = (i as i64).saturating_mul(gap_penalty);
         let ai = a[i - 1];
 
         // Process in cache-friendly blocks of 8.
@@ -132,9 +132,9 @@ pub fn needleman_wunsch_striped(a: &[u8], b: &[u8], match_score: i32, mismatch_s
                 let jj = j + k;
                 let old = row[jj];
                 let cost = if ai == b[jj - 1] { match_score } else { mismatch_score };
-                row[jj] = (prev_diag + cost)
-                    .max(row[jj] + gap_penalty)
-                    .max(row[jj - 1] + gap_penalty);
+                row[jj] = (prev_diag.saturating_add(cost))
+                    .max(row[jj].saturating_add(gap_penalty))
+                    .max(row[jj - 1].saturating_add(gap_penalty));
                 prev_diag = old;
             }
             j += 8;
@@ -143,9 +143,9 @@ pub fn needleman_wunsch_striped(a: &[u8], b: &[u8], match_score: i32, mismatch_s
         while j <= n {
             let old = row[j];
             let cost = if ai == b[j - 1] { match_score } else { mismatch_score };
-            row[j] = (prev_diag + cost)
-                .max(row[j] + gap_penalty)
-                .max(row[j - 1] + gap_penalty);
+            row[j] = (prev_diag.saturating_add(cost))
+                .max(row[j].saturating_add(gap_penalty))
+                .max(row[j - 1].saturating_add(gap_penalty));
             prev_diag = old;
             j += 1;
         }

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-python/Cargo.toml

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

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-python/src/lib.rs

@@ -1,17 +1,34 @@
 use pyo3::prelude::*;
+use std::sync::OnceLock;
 
 #[cfg(feature = "gpu")]
 use fuzzgpu_core::gpu::GpuEngine;
 
-// ── Helpers ──────────────────────────────────────────────────
+// ── Cached Environment Configuration ─────────────────────────
+
+static FORCE_GPU_CACHE: OnceLock<bool> = OnceLock::new();
+static DEBUG_CACHE: OnceLock<bool> = OnceLock::new();
 
 #[inline]
 fn is_force_gpu() -> bool {
-    if let Ok(v) = std::env::var("FUZZGPU_FORCE_GPU") {
-        v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes")
-    } else {
-        false
-    }
+    *FORCE_GPU_CACHE.get_or_init(|| {
+        if let Ok(v) = std::env::var("FUZZGPU_FORCE_GPU") {
+            v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes")
+        } else {
+            false
+        }
+    })
+}
+
+#[inline]
+fn is_debug_mode() -> bool {
+    *DEBUG_CACHE.get_or_init(|| {
+        if let Ok(v) = std::env::var("FUZZGPU_DEBUG") {
+            v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes")
+        } else {
+            false
+        }
+    })
 }
 
 // ── Levenshtein ──────────────────────────────────────────────
@@ -57,7 +74,7 @@ fn levenshtein_batch(py: Python, query: String, candidates: Vec<String>) -> PyRe
                                 e
                             )));
                         }
-                        if std::env::var("FUZZGPU_DEBUG").is_ok() {
+                        if is_debug_mode() {
                             eprintln!("fuzzgpu [fallback]: GPU kernel failed ({}), switching to Rayon CPU", e);
                         }
                     }
@@ -91,7 +108,7 @@ fn levenshtein_cdist(py: Python, list_a: Vec<String>, list_b: Vec<String>) -> Py
                                 e
                             )));
                         }
-                        if std::env::var("FUZZGPU_DEBUG").is_ok() {
+                        if is_debug_mode() {
                             eprintln!("fuzzgpu [fallback]: GPU matrix failed ({}), switching to Rayon CPU", e);
                         }
                     }
@@ -131,30 +148,30 @@ fn damerau_ratio(py: Python, a: &str, b: &str) -> PyResult<f64> {
     py.allow_threads(|| Ok(fuzzgpu_core::damerau_ratio(a, b)))
 }
 
-// ── Needleman-Wunsch ────────────────────────────────────────
+// ── Needleman-Wunsch (i64 Score Support) ─────────────────────
 
 #[pyfunction]
 #[pyo3(text_signature = "(a, b, match_score, mismatch_score, gap_penalty, /)")]
-fn needleman_wunsch_score(py: Python, a: &str, b: &str, match_score: i32, mismatch_score: i32, gap_penalty: i32) -> PyResult<i32> {
+fn needleman_wunsch_score(py: Python, a: &str, b: &str, match_score: i64, mismatch_score: i64, gap_penalty: i64) -> PyResult<i64> {
     py.allow_threads(|| Ok(fuzzgpu_core::needleman_wunsch(a, b, match_score, mismatch_score, gap_penalty)))
 }
 
 #[pyfunction]
 #[pyo3(text_signature = "(query, candidates, match_score, mismatch_score, gap_penalty, /)")]
-fn needleman_wunsch_batch_fn(py: Python, query: String, candidates: Vec<String>, match_score: i32, mismatch_score: i32, gap_penalty: i32) -> PyResult<Vec<i32>> {
+fn needleman_wunsch_batch_fn(py: Python, query: String, candidates: Vec<String>, match_score: i64, mismatch_score: i64, gap_penalty: i64) -> PyResult<Vec<i64>> {
     let refs: Vec<&str> = candidates.iter().map(|s| s.as_str()).collect();
     py.allow_threads(|| Ok(fuzzgpu_core::needleman_wunsch_batch(&query, &refs, match_score, mismatch_score, gap_penalty)))
 }
 
 #[pyfunction]
 #[pyo3(text_signature = "(a, b, match_score, mismatch_score, gap_open, gap_extend, /)")]
-fn needleman_wunsch_affine(py: Python, a: &str, b: &str, match_score: i32, mismatch_score: i32, gap_open: i32, gap_extend: i32) -> PyResult<i32> {
+fn needleman_wunsch_affine(py: Python, a: &str, b: &str, match_score: i64, mismatch_score: i64, gap_open: i64, gap_extend: i64) -> PyResult<i64> {
     py.allow_threads(|| Ok(fuzzgpu_core::needleman_wunsch_affine(a, b, match_score, mismatch_score, gap_open, gap_extend)))
 }
 
 #[pyfunction]
 #[pyo3(text_signature = "(query, candidates, match_score, mismatch_score, gap_open, gap_extend, /)")]
-fn needleman_wunsch_affine_batch(py: Python, query: String, candidates: Vec<String>, match_score: i32, mismatch_score: i32, gap_open: i32, gap_extend: i32) -> PyResult<Vec<i32>> {
+fn needleman_wunsch_affine_batch(py: Python, query: String, candidates: Vec<String>, match_score: i64, mismatch_score: i64, gap_open: i64, gap_extend: i64) -> PyResult<Vec<i64>> {
     let refs: Vec<&str> = candidates.iter().map(|s| s.as_str()).collect();
     py.allow_threads(|| Ok(fuzzgpu_core::needleman_wunsch_affine_batch(&query, &refs, match_score, mismatch_score, gap_open, gap_extend)))
 }
@@ -200,7 +217,7 @@ fn jaro_winkler_batch_fn(py: Python, query: String, candidates: Vec<String>, p:
                                 e
                             )));
                         }
-                        if std::env::var("FUZZGPU_DEBUG").is_ok() {
+                        if is_debug_mode() {
                             eprintln!("fuzzgpu [fallback]: GPU kernel failed ({}), switching to Rayon CPU", e);
                         }
                     }
@@ -235,7 +252,7 @@ fn jaro_winkler_cdist(py: Python, list_a: Vec<String>, list_b: Vec<String>, p: f
                                 e
                             )));
                         }
-                        if std::env::var("FUZZGPU_DEBUG").is_ok() {
+                        if is_debug_mode() {
                             eprintln!("fuzzgpu [fallback]: GPU matrix failed ({}), switching to Rayon CPU", e);
                         }
                     }
@@ -315,7 +332,7 @@ fn levenshtein_myers(py: Python, a: &str, b: &str) -> PyResult<u32> {
 
 #[pyfunction]
 #[pyo3(text_signature = "(a, b, match_score, mismatch_score, gap_penalty, /)")]
-fn needleman_wunsch_striped(py: Python, a: &str, b: &str, match_score: i32, mismatch_score: i32, gap_penalty: i32) -> PyResult<i32> {
+fn needleman_wunsch_striped(py: Python, a: &str, b: &str, match_score: i64, mismatch_score: i64, gap_penalty: i64) -> PyResult<i64> {
     py.allow_threads(|| {
         if a.is_ascii() && b.is_ascii() {
             Ok(fuzzgpu_core::needleman_wunsch_striped(a.as_bytes(), b.as_bytes(), match_score, mismatch_score, gap_penalty))
@@ -367,14 +384,20 @@ fn is_gpu_available() -> bool {
 
 #[pyfunction]
 #[pyo3(text_signature = "()")]
-fn warmup() -> bool {
+fn warmup() -> (bool, String) {
     #[cfg(feature = "gpu")]
     {
-        GpuEngine::get().is_ok()
+        if GpuEngine::is_cpu_only() {
+            return (false, "CPU-only mode is active (set via set_cpu_only or FUZZGPU_USE_CPU)".into());
+        }
+        match GpuEngine::get() {
+            Ok(engine) => (true, format!("GPU initialized: {} ({})", engine.info.name, engine.info.backend)),
+            Err(e) => (false, format!("GPU initialization failed ({}), using Rayon CPU fallback", e)),
+        }
     }
     #[cfg(not(feature = "gpu"))]
     {
-        true
+        (false, "Built without GPU support (cpu-only)".into())
     }
 }
 
@@ -388,7 +411,7 @@ fn gpu_info() -> PyResult<String> {
         }
         match GpuEngine::get() {
             Ok(engine) => Ok(format!("{} ({})", engine.info.name, engine.info.backend)),
-            Err(_) => Ok("CPU-only fallback mode (no GPU device detected)".into()),
+            Err(e) => Ok(format!("CPU-only fallback mode (GPU unavailable: {})", e)),
         }
     }
     #[cfg(not(feature = "gpu"))]

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/crates/fuzzgpu-wasm/Cargo.toml

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

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fuzzgpu"
-version = "0.1.2"
+version = "0.1.3"
 description = "Hardware-accelerated fuzzy string matching & sequence alignment — cross-platform, no CUDA required"
 readme = "README.md"
 license = { text = "MIT" }
@@ -26,6 +26,9 @@ classifiers = [
     "Topic :: Text Processing :: General",
 ]
 
+[project.optional-dependencies]
+test = ["pytest>=7.0", "pytest-benchmark"]
+
 [project.urls]
 Homepage = "https://github.com/kuntal-devrat/fuzzgpu"
 Repository = "https://github.com/kuntal-devrat/fuzzgpu"

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/tests/test_basic.py

@@ -320,4 +320,4 @@ class TestJaroOptimized:
 
 class TestVersion:
     def test_version_string(self):
-        assert fuzzgpu.__version__ == "0.1.2"
+        assert fuzzgpu.__version__ == "0.1.3"

{fuzzgpu-0.1.2 → fuzzgpu-0.1.3}/tests/test_edge_cases.py

@@ -336,3 +336,18 @@ class TestAlgorithmicEdgeScenarios:
         assert fuzzgpu.levenshtein_myers("café", "cafe") == 1
         assert fuzzgpu.levenshtein_myers("🚀", "") == 1
         assert fuzzgpu.jaro_optimized("café", "cafe") > 0.8
+
+    def test_needleman_i64_large_scores(self):
+        """Test that Needleman-Wunsch scores safely handle values exceeding 32-bit integer limits."""
+        large_match = 5_000_000_000
+        score = fuzzgpu.needleman_wunsch("AGCT", "AGCT", large_match, -1, -2)
+        assert score == 4 * large_match
+        score_affine = fuzzgpu.needleman_wunsch_affine("AGCT", "AGCT", large_match, -1, -3, -1)
+        assert score_affine == 4 * large_match
+
+    def test_warmup_diagnostics(self):
+        """Test warmup returns detailed status tuple."""
+        is_ok, msg = fuzzgpu.warmup()
+        assert isinstance(is_ok, bool)
+        assert isinstance(msg, str)
+        assert len(msg) > 0