Merge pull request #90 from StevenBtw/dev

Release 0.6.2

Author: StevenBtw

CHANGELOG.md

@@ -2,6 +2,20 @@
 
 What broke, what got fixed, and what's new.
 
+## [0.6.2] 2026-04-07
+
+### Fixed
+
+- **Rust:** Dijkstra, BFS, DFS, and Bellman-Ford now raise `ValueError` on out-of-bounds source/target instead of crashing the process.
+- **Rust:** Floyd-Warshall callback errors are now propagated to Python instead of being silently swallowed.
+- **Rust:** `PyList` construction in bindings uses proper error propagation instead of `unwrap()`.
+- **Rust:** Dijkstra and Kruskal use `total_cmp` for deterministic NaN handling in edge weights.
+- **Rust:** PageRank validates `damping`, `max_iter`, and `tol` parameters at the binding boundary.
+
+### Changed
+
+- **Rust:** Removed `hashbrown` and `ahash` dependencies from `Cargo.toml`.
+
 ## [0.6.1] - 2026-02-01
 
 ### Fixed

pyproject.toml

@@ -28,18 +28,18 @@ PyPI = "https://pypi.org/project/solvOR/"
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=9.0.2",
-    "pytest-cov>=7.0.0",
-    "ruff>=0.14.14",
+    "pytest>=9.0",
+    "pytest-cov>=7",
+    "ruff>=0.15",
     "pre-commit>=4.5.1",
-    "ty>=0.0.14",
+    "ty>=0.0.29",
     "maturin>=1.7,<2.0",
-    "prek>=0.3.1"
+    "prek>=0.3"
 ]
 docs = [
     "mkdocs>=1.6",
-    "mkdocs-material>=9.5",
-    "mkdocstrings[python]>=1.0.2",
+    "mkdocs-material>=9",
+    "mkdocstrings[python]>=1.0",
     "mkdocs-git-revision-date-localized-plugin>=1.5.1",
 ]
 

rust/Cargo.lock

@@ -11,8 +11,6 @@ crate-type = ["cdylib"]
 
 [dependencies]
 pyo3 = { version = "0.27", features = ["extension-module"] }
-hashbrown = "0.16.1"
-ahash = "0.8"
 
 [profile.release]
 lto = "thin"

rust/Cargo.toml

@@ -14,11 +14,8 @@ impl Eq for State {}
 
 impl Ord for State {
     fn cmp(&self, other: &Self) -> Ordering {
-        // Flip ordering for min-heap
-        other
-            .cost
-            .partial_cmp(&self.cost)
-            .unwrap_or(Ordering::Equal)
+        // Flip ordering for min-heap; total_cmp handles NaN deterministically
+        other.cost.total_cmp(&self.cost)
     }
 }
 

rust/src/algorithms/dijkstra.rs

@@ -3,8 +3,10 @@
 //! Time complexity: O(n³)
 //! Space complexity: O(n²)
 
+use pyo3::PyResult;
+
 use crate::callback::ProgressCallback;
-use crate::types::{AlgorithmResult, Progress, Status};
+use crate::types::Progress;
 
 /// Edge representation: (from, to, weight)
 pub type Edge = (usize, usize, f64);
@@ -36,7 +38,7 @@ pub fn floyd_warshall(
     n_nodes: usize,
     edges: &[Edge],
     callback: &mut ProgressCallback,
-) -> FloydWarshallResult {
+) -> PyResult<FloydWarshallResult> {
     let n = n_nodes;
 
     // Initialize distance matrix with infinity
@@ -63,14 +65,14 @@ pub fn floyd_warshall(
     for k in 0..n {
         // Report progress every n iterations (once per k)
         let progress = Progress::new(k, 0.0).with_evaluations(iterations);
-        if callback.report(&progress).unwrap_or(false) {
+        if callback.report(&progress)? {
             // Early termination requested
-            return FloydWarshallResult {
+            return Ok(FloydWarshallResult {
                 distances: dist,
                 predecessors: pred,
                 has_negative_cycle: false,
                 iterations,
-            };
+            });
         }
 
         for i in 0..n {
@@ -93,12 +95,12 @@ pub fn floyd_warshall(
         }
     }
 
-    FloydWarshallResult {
+    Ok(FloydWarshallResult {
         distances: dist,
         predecessors: pred,
         has_negative_cycle,
         iterations,
-    }
+    })
 }
 
 /// Reconstruct path from i to j using predecessor matrix.
@@ -148,7 +150,7 @@ mod tests {
     #[test]
     fn test_simple_graph() {
         let edges = vec![(0, 1, 1.0), (1, 2, 2.0), (0, 2, 5.0)];
-        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none());
+        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none()).unwrap();
 
         assert!((result.distances[0][2] - 3.0).abs() < 1e-9);
         assert!(!result.has_negative_cycle);
@@ -157,7 +159,7 @@ mod tests {
     #[test]
     fn test_no_path() {
         let edges = vec![(0, 1, 1.0)];
-        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none());
+        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none()).unwrap();
 
         assert!(result.distances[1][0].is_infinite());
         assert!(result.distances[2][0].is_infinite());
@@ -166,15 +168,15 @@ mod tests {
     #[test]
     fn test_negative_cycle() {
         let edges = vec![(0, 1, 1.0), (1, 2, -1.0), (2, 0, -1.0)];
-        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none());
+        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none()).unwrap();
 
         assert!(result.has_negative_cycle);
     }
 
     #[test]
     fn test_path_reconstruction() {
         let edges = vec![(0, 1, 1.0), (1, 2, 2.0), (0, 2, 5.0)];
-        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none());
+        let result = floyd_warshall(3, &edges, &mut ProgressCallback::none()).unwrap();
 
         let path = reconstruct_path(&result.predecessors, &result.distances, 0, 2);
         assert_eq!(path, Some(vec![0, 1, 2]));

rust/src/algorithms/floyd_warshall.rs

@@ -76,7 +76,7 @@ pub fn kruskal(n_nodes: usize, edges: &[(usize, usize, f64)]) -> KruskalResult {
 
     // Sort edges by weight
     let mut sorted_edges: Vec<(usize, usize, f64)> = edges.to_vec();
-    sorted_edges.sort_by(|a, b| a.2.partial_cmp(&b.2).unwrap_or(std::cmp::Ordering::Equal));
+    sorted_edges.sort_by(|a, b| a.2.total_cmp(&b.2));
 
     let mut uf = UnionFind::new(n_nodes);
     let mut mst_edges = Vec::with_capacity(n_nodes - 1);

rust/src/algorithms/kruskal.rs

@@ -55,7 +55,7 @@ pub fn pagerank(
     let mut new_scores = vec![0.0; n_nodes];
 
     let base = (1.0 - damping) / n_nodes as f64;
-    let mut converged = false;
+    let converged = false;
 
     for iteration in 0..max_iter {
         // Compute new scores

rust/src/algorithms/pagerank.rs

@@ -1,5 +1,6 @@
 //! PyO3 bindings for centrality algorithms.
 
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
@@ -27,6 +28,18 @@ pub fn pagerank(
     max_iter: usize,
     tol: f64,
 ) -> PyResult<Py<PyDict>> {
+    if !(0.0..1.0).contains(&damping) {
+        return Err(PyValueError::new_err(format!(
+            "damping {damping} must be in [0, 1)"
+        )));
+    }
+    if max_iter == 0 {
+        return Err(PyValueError::new_err("max_iter must be positive"));
+    }
+    if tol <= 0.0 {
+        return Err(PyValueError::new_err("tol must be positive"));
+    }
+
     let result = py.detach(|| pr::pagerank(n_nodes, &edges, damping, max_iter, tol));
 
     let dict = PyDict::new(py);

rust/src/bindings/centrality.rs

@@ -26,13 +26,12 @@ pub fn strongly_connected_components(
     let dict = PyDict::new(py);
 
     // Convert components to list of lists
-    let py_components = PyList::new(
-        py,
-        result
-            .components
-            .iter()
-            .map(|comp| PyList::new(py, comp.iter()).unwrap()),
-    )?;
+    let inner_lists = result
+        .components
+        .iter()
+        .map(|comp| PyList::new(py, comp.iter()))
+        .collect::<PyResult<Vec<_>>>()?;
+    let py_components = PyList::new(py, inner_lists)?;
     dict.set_item("components", py_components)?;
     dict.set_item("n_components", result.n_components)?;
     dict.set_item("status", Status::Optimal.as_i32())?;