differt-core 0.5.0__tar.gz → 0.6.0__tar.gz

{differt_core-0.5.0 → differt_core-0.6.0}/Cargo.lock

@@ -247,7 +247,7 @@ checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
 
 [[package]]
 name = "differt-core"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "criterion",
  "indexmap",

{differt_core-0.5.0 → differt_core-0.6.0}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: differt-core
-Version: 0.5.0
+Version: 0.6.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -17,7 +16,7 @@ License-File: LICENSE.md
 Summary: Core backend of DiffeRT implemented in Rust
 Keywords: ray tracing,differentiable,propagation,radio,jax
 Author-email: Jérome Eertmans <jeertmans@icloud.com>
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 <div align="center">

{differt_core-0.5.0 → differt_core-0.6.0}/differt-core/Cargo.toml

@@ -10,7 +10,7 @@ ndarray = {version = "0.16", features = ["rayon"]}
 numpy = "0.25"
 obj-rs = "0.7.1"
 ply-rs = "0.1.3"
-pyo3 = {version = "0.25", features = ["abi3-py310", "indexmap", "generate-import-lib"]}
+pyo3 = {version = "0.25", features = ["abi3-py311", "indexmap", "generate-import-lib"]}
 pyo3-log = "0.12.4"
 quick-xml = {version = "0.37.2", features = ["serialize", "serde-types"]}
 serde = {version = "1.0", features = ["derive"]}
@@ -37,4 +37,5 @@ unexpected_cfgs = {level = "warn", check-cfg = ['cfg(tarpaulin_include)']}
 edition = "2021"
 name = "differt-core"
 rust-version = "1.78.0"
-version = "0.5.0"
+version = "0.6.0"
+readme = "README.md"

{differt_core-0.5.0 → differt_core-0.6.0}/differt-core/python/differt_core/_differt_core/rt/graph.pyi

@@ -52,6 +52,9 @@ class DiGraph:
         to_adjacency: Bool[np.ndarray, " num_nodes"],
     ) -> tuple[int, int]: ...
     def disconnect_nodes(self, *nodes: int, fast_mode: bool = True) -> None: ...
+    def filter_by_mask(
+        self, mask: Bool[np.ndarray, " num_nodes"], fast_mode: bool = True
+    ) -> None: ...
     def all_paths(
         self,
         from_: int,

{differt_core-0.5.0 → differt_core-0.6.0}/differt-core/src/rt/graph.rs

@@ -6,7 +6,11 @@ use numpy::{
     IntoPyArray, PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2,
     ndarray::{Array2, ArrayView1, ArrayView2, Axis, parallel::prelude::*},
 };
-use pyo3::{prelude::*, types::PyType};
+use pyo3::{
+    exceptions::{PyIndexError, PyValueError},
+    prelude::*,
+    types::PyType,
+};
 
 /// NodeId type.
 pub type NodeId = usize;
@@ -820,11 +824,18 @@ pub mod directed {
         ///         from the nodes is sufficient, and faster to perform,
         ///         but can lead to a slower graph traversal when
         ///         generating all possible paths.
+        ///
+        /// Raises:
+        ///     IndexError: If any of the specified nodes is not part
+        ///         of the graph.
         #[pyo3(signature = (*nodes, fast_mode=true))]
         #[pyo3(text_signature = "(self, *nodes, fast_mode=True)")]
-        pub fn disconnect_nodes(&mut self, mut nodes: Vec<usize>, fast_mode: bool) {
+        pub fn disconnect_nodes(&mut self, mut nodes: Vec<usize>, fast_mode: bool) -> PyResult<()> {
             for i in nodes.iter() {
-                self.edges_list[*i].clear();
+                self.edges_list
+                    .get_mut(*i)
+                    .ok_or_else(|| PyIndexError::new_err(format!("Node {i} is out-of-bounds")))?
+                    .clear();
             }
 
             if !fast_mode {
@@ -834,6 +845,68 @@ pub mod directed {
                     edge.retain(|node| nodes.binary_search(node).is_err());
                 }
             }
+
+            Ok(())
+        }
+
+        /// Disconnect all nodes where the mask is False, keeping only
+        /// nodes where the mask is True.
+        ///
+        /// This is a more efficient version of :meth:`disconnect_nodes` when
+        /// working with NumPy boolean arrays, as it avoids creating
+        /// intermediate Vec<usize> collections.
+        ///
+        /// This has two effects:
+        ///
+        /// - all paths from nodes where mask is False will be removed;
+        /// - and all paths to nodes where mask is False will be removed.
+        ///
+        /// Args:
+        ///     mask (:class:`Bool[ndarray, "num_nodes"]<jaxtyping.Bool>`): A boolean mask array where
+        ///         :data:`True` means the node should remain connected, and
+        ///         :data:`False` means the node should be disconnected.
+        ///     fast_mode (bool): If set to :data:`True` (default),
+        ///         only disconnecting all paths (i.e., edges)
+        ///         from the nodes is sufficient, and faster to perform,
+        ///         but can lead to a slower graph traversal when
+        ///         generating all possible paths.
+        ///
+        /// Raises:
+        ///     ValueError: If the length of ``mask`` is larger
+        ///         from the number of nodes in the graph.
+        #[pyo3(signature = (mask, fast_mode=true))]
+        #[pyo3(text_signature = "(self, mask, fast_mode=True)")]
+        pub fn filter_by_mask(
+            &mut self,
+            mask: PyReadonlyArray1<bool>,
+            fast_mode: bool,
+        ) -> PyResult<()> {
+            let mask = mask.as_array();
+
+            if mask.len() > self.num_nodes() {
+                return Err(PyValueError::new_err(format!(
+                    "'mask' length ({}) must be smaller than or equal to the number of nodes in \
+                     the graph ({})",
+                    mask.len(),
+                    self.num_nodes()
+                )));
+            }
+
+            // Clear edges from nodes that should be disconnected
+            for (i, &keep_node) in mask.iter().enumerate() {
+                if !keep_node {
+                    self.edges_list[i].clear();
+                }
+            }
+
+            if !fast_mode {
+                // Remove references to disconnected nodes from all other nodes
+                for edge_list in self.edges_list.iter_mut() {
+                    edge_list.retain(|&node| if node < mask.len() { mask[node] } else { true });
+                }
+            }
+
+            Ok(())
         }
 
         /// Return an iterator over all paths of length ``depth``
@@ -1135,7 +1208,7 @@ pub(crate) fn graph(m: Bound<'_, PyModule>) -> PyResult<()> {
 mod tests {
     use std::cmp::Ordering;
 
-    use ndarray::array;
+    use numpy::{PyArrayMethods, ToPyArray, ndarray::array, pyo3::Python};
     use rstest::*;
 
     use super::{complete::CompleteGraph, directed::DiGraph, *};
@@ -1502,4 +1575,132 @@ mod tests {
 
         assert!(complete_iter.eq(di_iter));
     }
+
+    #[rstest]
+    #[case(true)]
+    #[case(false)]
+    fn test_di_graph_disconnect_node(#[case] fast_mode: bool) {
+        let mut graph: DiGraph = CompleteGraph::new(10).into();
+        let (from, to) = graph.insert_from_and_to_nodes(true, None, None);
+
+        // Count paths before disconnecting any nodes
+        let paths_before = graph.all_paths(from, to, 3, false).count();
+
+        // Disconnect nodes 2 and 5
+        let disconnected_nodes = vec![2, 5];
+        graph
+            .disconnect_nodes(disconnected_nodes.clone(), fast_mode)
+            .unwrap();
+
+        // Count paths after disconnecting nodes
+        let paths_after: Vec<_> = graph.all_paths(from, to, 3, false).collect();
+
+        // Verify that no path contains any of the disconnected nodes
+        for path in &paths_after {
+            for &node in &disconnected_nodes {
+                assert!(
+                    !path.contains(&node),
+                    "Path {:?} should not contain disconnected node {}",
+                    path,
+                    node
+                );
+            }
+        }
+
+        // Verify that we have fewer paths after disconnection
+        assert!(
+            paths_after.len() < paths_before,
+            "Should have fewer paths after disconnecting nodes"
+        );
+
+        // Test disconnecting a single node
+        let mut graph2: DiGraph = CompleteGraph::new(5).into();
+        let (from2, to2) = graph2.insert_from_and_to_nodes(true, None, None);
+
+        let paths_before2 = graph2.all_paths(from2, to2, 4, false).count();
+        graph2.disconnect_nodes(vec![1], fast_mode).unwrap();
+        let paths_after2: Vec<_> = graph2.all_paths(from2, to2, 4, false).collect();
+
+        // Verify node 1 is not in any path
+        for path in &paths_after2 {
+            assert!(
+                !path.contains(&1),
+                "Path {:?} should not contain disconnected node 1",
+                path
+            );
+        }
+
+        assert!(paths_after2.len() < paths_before2);
+
+        // Test disconnecting all intermediate nodes (should result in no paths for depth > 2)
+        let mut graph3: DiGraph = CompleteGraph::new(3).into();
+        let (from3, to3) = graph3.insert_from_and_to_nodes(false, None, None); // No direct path
+
+        // Disconnect all intermediate nodes (0, 1, 2)
+        graph3.disconnect_nodes(vec![0, 1, 2], fast_mode).unwrap();
+        let paths_after3 = graph3.all_paths(from3, to3, 4, false).count();
+
+        // Should have no paths since all intermediate nodes are disconnected
+        assert_eq!(
+            paths_after3, 0,
+            "Should have no paths when all intermediate nodes are disconnected"
+        );
+    }
+
+    #[rstest]
+    #[case(true)]
+    #[case(false)]
+    fn test_di_graph_filter_by_mask(#[case] fast_mode: bool) {
+        Python::with_gil(|py| {
+            let mut graph: DiGraph = CompleteGraph::new(8).into();
+            let (from, to) = graph.insert_from_and_to_nodes(true, None, None);
+
+            // Count paths before filtering
+            let paths_before = graph.all_paths(from, to, 3, false).count();
+
+            // Create a mask that keeps nodes 0, 2, 4, 6 and disconnects 1, 3, 5, 7
+            let mask = array![true, false, true, false, true, false, true, false].to_pyarray(py);
+
+            // Apply the mask filter
+            graph.filter_by_mask(mask.readonly(), fast_mode).unwrap();
+
+            // Count paths after filtering
+            let paths_after: Vec<_> = graph.all_paths(from, to, 3, false).collect();
+
+            // Verify that no path contains any of the disconnected nodes (1, 3, 5, 7)
+            let disconnected_nodes = vec![1, 3, 5, 7];
+            for path in &paths_after {
+                for &node in &disconnected_nodes {
+                    assert!(
+                        !path.contains(&node),
+                        "Path {:?} should not contain disconnected node {}",
+                        path,
+                        node
+                    );
+                }
+            }
+
+            // Verify that we have fewer paths after filtering
+            assert!(
+                paths_after.len() < paths_before,
+                "Should have fewer paths after filtering by mask"
+            );
+
+            // Test with a mask that disconnects all nodes (should result in no paths)
+            let mut graph2: DiGraph = CompleteGraph::new(4).into();
+            let (from2, to2) = graph2.insert_from_and_to_nodes(false, None, None);
+
+            // Disconnect all intermediate nodes
+            let all_false_mask = ndarray::array![false, false, false, false].to_pyarray(py);
+            graph2
+                .filter_by_mask(all_false_mask.readonly(), fast_mode)
+                .unwrap();
+
+            let paths_after2 = graph2.all_paths(from2, to2, 4, false).count();
+            assert_eq!(
+                paths_after2, 0,
+                "Should have no paths when all nodes are disconnected"
+            );
+        });
+    }
 }

{differt_core-0.5.0 → differt_core-0.6.0}/differt-core/tests/rt/test_graph.py

@@ -1,4 +1,5 @@
 import logging
+import re
 
 import numpy as np
 import pytest
@@ -46,6 +47,76 @@ class TestDiGraph:
                 for node in nodes:
                     assert node not in path
 
+    @pytest.mark.parametrize("fast_mode", [True, False])
+    def test_filter_by_mask(self, fast_mode: bool) -> None:
+        graph = DiGraph.from_complete_graph(CompleteGraph(8))
+        from_, to = graph.insert_from_and_to_nodes()
+
+        # Create a mask that disconnects nodes 1, 3, 5, 7 (keeps 0, 2, 4, 6)
+        mask = np.array([True, False, True, False, True, False, True, False])
+        disconnected_nodes = [1, 3, 5, 7]
+
+        # Count paths before filtering
+        paths_before = len(
+            list(graph.all_paths(from_, to, 3, include_from_and_to=False))
+        )
+
+        # Apply the mask filter
+        graph.filter_by_mask(mask, fast_mode=fast_mode)
+
+        # Count paths after filtering and verify no disconnected nodes appear
+        paths_after = []
+        for path in graph.all_paths(from_, to, 3, include_from_and_to=False):
+            paths_after.append(path)
+            for node in disconnected_nodes:
+                assert node not in path, (
+                    f"Path {path} should not contain disconnected node {node}"
+                )
+
+        # Verify that we have fewer paths after filtering
+        assert len(paths_after) < paths_before, (
+            "Should have fewer paths after filtering by mask"
+        )
+
+    @pytest.mark.parametrize("fast_mode", [True, False])
+    def test_filter_by_mask_all_disconnected(self, fast_mode: bool) -> None:
+        graph = DiGraph.from_complete_graph(CompleteGraph(4))
+        from_, to = graph.insert_from_and_to_nodes(direct_path=False)
+
+        # Disconnect all intermediate nodes
+        mask = np.array([False, False, False, False])
+        graph.filter_by_mask(mask, fast_mode=fast_mode)
+
+        # Should have no paths when all intermediate nodes are disconnected
+        paths = list(graph.all_paths(from_, to, 4, include_from_and_to=False))
+        assert len(paths) == 0, "Should have no paths when all nodes are disconnected"
+
+    def test_filter_by_mask_wrong_size(self) -> None:
+        graph = DiGraph.from_complete_graph(CompleteGraph(5))
+
+        # Test with mask of wrong size
+        wrong_mask = np.array([True, False, True])  # Only 3 elements for 5 nodes
+        # Ok to use a smaller mask
+        graph.filter_by_mask(wrong_mask, fast_mode=True)
+
+        graph = DiGraph.from_complete_graph(CompleteGraph(5))
+
+        wrong_mask = np.array([
+            True,
+            False,
+            True,
+            False,
+            False,
+            False,
+        ])  # 6 elements for 5 nodes
+        with pytest.raises(
+            ValueError,
+            match=re.escape(
+                "'mask' length (6) must be smaller than or equal to the number of nodes in the graph (5)"
+            ),
+        ):
+            graph.filter_by_mask(wrong_mask, fast_mode=True)
+
     @pytest.mark.parametrize("fast_mode", [True, False])
     def test_disconnect_nodes_equivalence(self, fast_mode: bool) -> None:
         complete_graph = CompleteGraph(3)

{differt_core-0.5.0 → differt_core-0.6.0}/pyproject.toml

@@ -8,7 +8,6 @@ authors = [
 ]
 classifiers = [
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -24,7 +23,7 @@ description = "Core backend of DiffeRT implemented in Rust"
 dynamic = ["license", "readme", "version"]
 keywords = ["ray tracing", "differentiable", "propagation", "radio", "jax"]
 name = "differt-core"
-requires-python = ">= 3.10"
+requires-python = ">= 3.11"
 
 [tool.maturin]
 bindings = "pyo3"

{differt_core-0.5.0 → differt_core-0.6.0}/python/differt_core/_differt_core/rt/graph.pyi

@@ -52,6 +52,9 @@ class DiGraph:
         to_adjacency: Bool[np.ndarray, " num_nodes"],
     ) -> tuple[int, int]: ...
     def disconnect_nodes(self, *nodes: int, fast_mode: bool = True) -> None: ...
+    def filter_by_mask(
+        self, mask: Bool[np.ndarray, " num_nodes"], fast_mode: bool = True
+    ) -> None: ...
     def all_paths(
         self,
         from_: int,

{differt_core-0.5.0 → differt_core-0.6.0}/src/rt/graph.rs

@@ -6,7 +6,11 @@ use numpy::{
     IntoPyArray, PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2,
     ndarray::{Array2, ArrayView1, ArrayView2, Axis, parallel::prelude::*},
 };
-use pyo3::{prelude::*, types::PyType};
+use pyo3::{
+    exceptions::{PyIndexError, PyValueError},
+    prelude::*,
+    types::PyType,
+};
 
 /// NodeId type.
 pub type NodeId = usize;
@@ -820,11 +824,18 @@ pub mod directed {
         ///         from the nodes is sufficient, and faster to perform,
         ///         but can lead to a slower graph traversal when
         ///         generating all possible paths.
+        ///
+        /// Raises:
+        ///     IndexError: If any of the specified nodes is not part
+        ///         of the graph.
         #[pyo3(signature = (*nodes, fast_mode=true))]
         #[pyo3(text_signature = "(self, *nodes, fast_mode=True)")]
-        pub fn disconnect_nodes(&mut self, mut nodes: Vec<usize>, fast_mode: bool) {
+        pub fn disconnect_nodes(&mut self, mut nodes: Vec<usize>, fast_mode: bool) -> PyResult<()> {
             for i in nodes.iter() {
-                self.edges_list[*i].clear();
+                self.edges_list
+                    .get_mut(*i)
+                    .ok_or_else(|| PyIndexError::new_err(format!("Node {i} is out-of-bounds")))?
+                    .clear();
             }
 
             if !fast_mode {
@@ -834,6 +845,68 @@ pub mod directed {
                     edge.retain(|node| nodes.binary_search(node).is_err());
                 }
             }
+
+            Ok(())
+        }
+
+        /// Disconnect all nodes where the mask is False, keeping only
+        /// nodes where the mask is True.
+        ///
+        /// This is a more efficient version of :meth:`disconnect_nodes` when
+        /// working with NumPy boolean arrays, as it avoids creating
+        /// intermediate Vec<usize> collections.
+        ///
+        /// This has two effects:
+        ///
+        /// - all paths from nodes where mask is False will be removed;
+        /// - and all paths to nodes where mask is False will be removed.
+        ///
+        /// Args:
+        ///     mask (:class:`Bool[ndarray, "num_nodes"]<jaxtyping.Bool>`): A boolean mask array where
+        ///         :data:`True` means the node should remain connected, and
+        ///         :data:`False` means the node should be disconnected.
+        ///     fast_mode (bool): If set to :data:`True` (default),
+        ///         only disconnecting all paths (i.e., edges)
+        ///         from the nodes is sufficient, and faster to perform,
+        ///         but can lead to a slower graph traversal when
+        ///         generating all possible paths.
+        ///
+        /// Raises:
+        ///     ValueError: If the length of ``mask`` is larger
+        ///         from the number of nodes in the graph.
+        #[pyo3(signature = (mask, fast_mode=true))]
+        #[pyo3(text_signature = "(self, mask, fast_mode=True)")]
+        pub fn filter_by_mask(
+            &mut self,
+            mask: PyReadonlyArray1<bool>,
+            fast_mode: bool,
+        ) -> PyResult<()> {
+            let mask = mask.as_array();
+
+            if mask.len() > self.num_nodes() {
+                return Err(PyValueError::new_err(format!(
+                    "'mask' length ({}) must be smaller than or equal to the number of nodes in \
+                     the graph ({})",
+                    mask.len(),
+                    self.num_nodes()
+                )));
+            }
+
+            // Clear edges from nodes that should be disconnected
+            for (i, &keep_node) in mask.iter().enumerate() {
+                if !keep_node {
+                    self.edges_list[i].clear();
+                }
+            }
+
+            if !fast_mode {
+                // Remove references to disconnected nodes from all other nodes
+                for edge_list in self.edges_list.iter_mut() {
+                    edge_list.retain(|&node| if node < mask.len() { mask[node] } else { true });
+                }
+            }
+
+            Ok(())
         }
 
         /// Return an iterator over all paths of length ``depth``
@@ -1135,7 +1208,7 @@ pub(crate) fn graph(m: Bound<'_, PyModule>) -> PyResult<()> {
 mod tests {
     use std::cmp::Ordering;
 
-    use ndarray::array;
+    use numpy::{PyArrayMethods, ToPyArray, ndarray::array, pyo3::Python};
     use rstest::*;
 
     use super::{complete::CompleteGraph, directed::DiGraph, *};
@@ -1502,4 +1575,132 @@ mod tests {
 
         assert!(complete_iter.eq(di_iter));
     }
+
+    #[rstest]
+    #[case(true)]
+    #[case(false)]
+    fn test_di_graph_disconnect_node(#[case] fast_mode: bool) {
+        let mut graph: DiGraph = CompleteGraph::new(10).into();
+        let (from, to) = graph.insert_from_and_to_nodes(true, None, None);
+
+        // Count paths before disconnecting any nodes
+        let paths_before = graph.all_paths(from, to, 3, false).count();
+
+        // Disconnect nodes 2 and 5
+        let disconnected_nodes = vec![2, 5];
+        graph
+            .disconnect_nodes(disconnected_nodes.clone(), fast_mode)
+            .unwrap();
+
+        // Count paths after disconnecting nodes
+        let paths_after: Vec<_> = graph.all_paths(from, to, 3, false).collect();
+
+        // Verify that no path contains any of the disconnected nodes
+        for path in &paths_after {
+            for &node in &disconnected_nodes {
+                assert!(
+                    !path.contains(&node),
+                    "Path {:?} should not contain disconnected node {}",
+                    path,
+                    node
+                );
+            }
+        }
+
+        // Verify that we have fewer paths after disconnection
+        assert!(
+            paths_after.len() < paths_before,
+            "Should have fewer paths after disconnecting nodes"
+        );
+
+        // Test disconnecting a single node
+        let mut graph2: DiGraph = CompleteGraph::new(5).into();
+        let (from2, to2) = graph2.insert_from_and_to_nodes(true, None, None);
+
+        let paths_before2 = graph2.all_paths(from2, to2, 4, false).count();
+        graph2.disconnect_nodes(vec![1], fast_mode).unwrap();
+        let paths_after2: Vec<_> = graph2.all_paths(from2, to2, 4, false).collect();
+
+        // Verify node 1 is not in any path
+        for path in &paths_after2 {
+            assert!(
+                !path.contains(&1),
+                "Path {:?} should not contain disconnected node 1",
+                path
+            );
+        }
+
+        assert!(paths_after2.len() < paths_before2);
+
+        // Test disconnecting all intermediate nodes (should result in no paths for depth > 2)
+        let mut graph3: DiGraph = CompleteGraph::new(3).into();
+        let (from3, to3) = graph3.insert_from_and_to_nodes(false, None, None); // No direct path
+
+        // Disconnect all intermediate nodes (0, 1, 2)
+        graph3.disconnect_nodes(vec![0, 1, 2], fast_mode).unwrap();
+        let paths_after3 = graph3.all_paths(from3, to3, 4, false).count();
+
+        // Should have no paths since all intermediate nodes are disconnected
+        assert_eq!(
+            paths_after3, 0,
+            "Should have no paths when all intermediate nodes are disconnected"
+        );
+    }
+
+    #[rstest]
+    #[case(true)]
+    #[case(false)]
+    fn test_di_graph_filter_by_mask(#[case] fast_mode: bool) {
+        Python::with_gil(|py| {
+            let mut graph: DiGraph = CompleteGraph::new(8).into();
+            let (from, to) = graph.insert_from_and_to_nodes(true, None, None);
+
+            // Count paths before filtering
+            let paths_before = graph.all_paths(from, to, 3, false).count();
+
+            // Create a mask that keeps nodes 0, 2, 4, 6 and disconnects 1, 3, 5, 7
+            let mask = array![true, false, true, false, true, false, true, false].to_pyarray(py);
+
+            // Apply the mask filter
+            graph.filter_by_mask(mask.readonly(), fast_mode).unwrap();
+
+            // Count paths after filtering
+            let paths_after: Vec<_> = graph.all_paths(from, to, 3, false).collect();
+
+            // Verify that no path contains any of the disconnected nodes (1, 3, 5, 7)
+            let disconnected_nodes = vec![1, 3, 5, 7];
+            for path in &paths_after {
+                for &node in &disconnected_nodes {
+                    assert!(
+                        !path.contains(&node),
+                        "Path {:?} should not contain disconnected node {}",
+                        path,
+                        node
+                    );
+                }
+            }
+
+            // Verify that we have fewer paths after filtering
+            assert!(
+                paths_after.len() < paths_before,
+                "Should have fewer paths after filtering by mask"
+            );
+
+            // Test with a mask that disconnects all nodes (should result in no paths)
+            let mut graph2: DiGraph = CompleteGraph::new(4).into();
+            let (from2, to2) = graph2.insert_from_and_to_nodes(false, None, None);
+
+            // Disconnect all intermediate nodes
+            let all_false_mask = ndarray::array![false, false, false, false].to_pyarray(py);
+            graph2
+                .filter_by_mask(all_false_mask.readonly(), fast_mode)
+                .unwrap();
+
+            let paths_after2 = graph2.all_paths(from2, to2, 4, false).count();
+            assert_eq!(
+                paths_after2, 0,
+                "Should have no paths when all nodes are disconnected"
+            );
+        });
+    }
 }