Add flags multigraph and selfloops to read_edge_list methods (#1526)

* add flags mutligraph and selfloops to read_edge_list

* Apply suggestions from code review

* Use macos-15-intel to unblock CI

---------

Co-authored-by: Ivan Carvalho <[email protected]>
Co-authored-by: Ivan Carvalho <[email protected]>

Author: SILIZ4

.github/workflows/main.yml

@@ -63,7 +63,7 @@ jobs:
         rust: [stable]
         python-version: [3.9, "3.10", "3.11", "3.12", "3.13"]
         platform: [
-          { os: "macOS-13", python-architecture: "x64", rust-target: "x86_64-apple-darwin" },
+          { os: "macos-15-intel", python-architecture: "x64", rust-target: "x86_64-apple-darwin" },
           { os: "macOS-14", python-architecture: "arm64", rust-target: "aarch64-apple-darwin" },
           { os: "ubuntu-latest", python-architecture: "x64", rust-target: "x86_64-unknown-linux-gnu" },
           { os: "ubuntu-24.04-arm", python-architecture: "arm64", rust-target: "aarch64-unknown-linux-gnu" },

releasenotes/notes/read-edgelist-simple-graph-a2ecafd555906520.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    Adds the flags ``multigraph`` and ``allow_self_loops`` to the ``read_edge_list`` methods of :class:`rustwork.PyGraph` and :class:`rustworkx.PyDiGraph`.
+    When the flag ``multigraph`` is set to ``False``, no parallel edge is created, but the edge weight is updated.
+    The edge weight is the last one found in the edge list file.
+    When flag ``allow_self_loops` is set to ``False``, the self-loops in the edge list file are ignored.

rustworkx/rustworkx.pyi

@@ -1387,6 +1387,8 @@ class PyGraph(Generic[_S, _T]):
         comment: str | None = ...,
         deliminator: str | None = ...,
         labels: bool = ...,
+        multigraph: bool = ...,
+        allow_self_loops: bool = ...,
     ) -> PyGraph: ...
     def remove_edge(self, node_a: int, node_b: int, /) -> None: ...
     def remove_edge_from_index(self, edge: int, /) -> None: ...
@@ -1581,6 +1583,8 @@ class PyDiGraph(Generic[_S, _T]):
         comment: str | None = ...,
         deliminator: str | None = ...,
         labels: bool = ...,
+        multigraph: bool = ...,
+        allow_self_loops: bool = ...,
     ) -> PyDiGraph: ...
     def remove_edge(self, parent: int, child: int, /) -> None: ...
     def remove_edge_from_index(self, edge: int, /) -> None: ...

src/digraph.rs

@@ -2458,6 +2458,10 @@ impl PyDiGraph {
     /// :param bool labels: If set to ``True`` the first two separated fields
     ///     will be treated as string labels uniquely identifying a node
     ///     instead of node indices.
+    /// :param bool multigraph: If ``False``, duplicate edges do not create
+    ///     parallel edges. Instead, repeated edges overwrite the previous
+    ///     weight, with the last one in the input determining the final weight.
+    /// :param bool selfloops: If set to ``False``, self-loops are not created.
     ///
     /// For example:
     ///
@@ -2480,14 +2484,18 @@ impl PyDiGraph {
     ///   mpl_draw(graph)
     ///
     #[staticmethod]
-    #[pyo3(signature=(path, comment=None, deliminator=None, labels=false))]
-    #[pyo3(text_signature = "(path, /, comment=None, deliminator=None, labels=False)")]
+    #[pyo3(signature=(path, comment=None, deliminator=None, labels=false, multigraph=true, allow_self_loops=true))]
+    #[pyo3(
+        text_signature = "(path, /, comment=None, deliminator=None, labels=False, multigraph=True, allow_self_loops=True)"
+    )]
     pub fn read_edge_list(
         py: Python,
         path: &str,
         comment: Option<String>,
         deliminator: Option<String>,
         labels: bool,
+        multigraph: bool,
+        allow_self_loops: bool,
     ) -> PyResult<PyDiGraph> {
         let file = File::open(path)?;
         let buf_reader = BufReader::new(file);
@@ -2555,14 +2563,20 @@ impl PyDiGraph {
             } else {
                 py.None()
             };
-            out_graph.add_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+            if allow_self_loops || src != target {
+                if multigraph {
+                    out_graph.add_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+                } else {
+                    out_graph.update_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+                }
+            }
         }
         Ok(PyDiGraph {
             graph: out_graph,
             cycle_state: algo::DfsSpace::default(),
             check_cycle: false,
             node_removed: false,
-            multigraph: true,
+            multigraph,
             attrs: py.None(),
         })
     }

src/graph.rs

@@ -1347,6 +1347,10 @@ impl PyGraph {
     /// :param bool labels: If set to ``True`` the first two separated fields
     ///     will be treated as string labels uniquely identifying a node
     ///     instead of node indices
+    /// :param bool multigraph: If ``False``, duplicate edges do not create
+    ///     parallel edges. Instead, repeated edges overwrite the previous
+    ///     weight, with the last one in the input determining the final weight.
+    /// :param bool selfloops: If set to ``False``, self-loops are not created.
     ///
     /// For example:
     ///
@@ -1369,13 +1373,18 @@ impl PyGraph {
     ///   mpl_draw(graph)
     ///
     #[staticmethod]
-    #[pyo3(signature=(path, comment=None, deliminator=None, labels=false),  text_signature = "(path, /, comment=None, deliminator=None, labels=False)")]
+    #[pyo3(signature=(path, comment=None, deliminator=None, labels=false, multigraph=true, allow_self_loops=true))]
+    #[pyo3(
+        text_signature = "(path, /, comment=None, deliminator=None, labels=False, multigraph=True, allow_self_loops=True)"
+    )]
     pub fn read_edge_list(
         py: Python,
         path: &str,
         comment: Option<String>,
         deliminator: Option<String>,
         labels: bool,
+        multigraph: bool,
+        allow_self_loops: bool,
     ) -> PyResult<PyGraph> {
         let file = File::open(path)?;
         let buf_reader = BufReader::new(file);
@@ -1443,12 +1452,18 @@ impl PyGraph {
             } else {
                 py.None()
             };
-            out_graph.add_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+            if allow_self_loops || src != target {
+                if multigraph {
+                    out_graph.add_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+                } else {
+                    out_graph.update_edge(NodeIndex::new(src), NodeIndex::new(target), weight);
+                }
+            }
         }
         Ok(PyGraph {
             graph: out_graph,
             node_removed: false,
-            multigraph: true,
+            multigraph,
             attrs: py.None(),
         })
     }

tests/digraph/test_edgelist.py

@@ -147,6 +147,37 @@ def test_labels_digraph_target_existing(self):
         self.assertTrue(graph.has_edge(0, 2))
         self.assertEqual(graph.edges(), ["0", "1", None])
 
+    def test_remove_parallel_edges_digraph(self):
+        with tempfile.NamedTemporaryFile("wt") as fd:
+            fd.write("0 1\n")
+            fd.write("1 1 a\n")
+            fd.write("1 1 b\n")
+            fd.write("1 2 c\n")
+            fd.write("1 2 d\n")
+            fd.flush()
+            graph = rustworkx.PyDiGraph.read_edge_list(fd.name, multigraph=False)
+        self.assertTrue(graph.node_indexes(), [0, 1, 2])
+        self.assertTrue(graph.has_edge(0, 1))
+        self.assertTrue(graph.has_edge(1, 2))
+        self.assertTrue(graph.has_edge(1, 1))
+        self.assertEqual(graph.edges(), [None, "b", "d"])
+        self.assertFalse(graph.multigraph)
+
+    def test_remove_selfloops_digraph(self):
+        with tempfile.NamedTemporaryFile("wt") as fd:
+            fd.write("0 1\n")
+            fd.write("1 1 a\n")
+            fd.write("1 1 b\n")
+            fd.write("1 2 c\n")
+            fd.write("1 2 d\n")
+            fd.flush()
+            graph = rustworkx.PyDiGraph.read_edge_list(fd.name, allow_self_loops=False)
+        self.assertTrue(graph.node_indexes(), [0, 1, 2])
+        self.assertTrue(graph.has_edge(0, 1))
+        self.assertTrue(graph.has_edge(1, 2))
+        self.assertFalse(graph.has_edge(1, 1))
+        self.assertEqual(graph.edges(), [None, "c", "d"])
+
     def test_write_edge_list_empty_digraph(self):
         path = os.path.join(tempfile.gettempdir(), "empty.txt")
         graph = rustworkx.PyDiGraph()

tests/graph/test_edgelist.py

@@ -143,6 +143,37 @@ def test_labels_graph_target_existing(self):
         self.assertTrue(graph.has_edge(0, 2))
         self.assertEqual(graph.edges(), ["0", "1", None])
 
+    def test_remove_parallel_edges_graph(self):
+        with tempfile.NamedTemporaryFile("wt") as fd:
+            fd.write("0 1\n")
+            fd.write("1 1 a\n")
+            fd.write("1 1 b\n")
+            fd.write("2 1 c\n")
+            fd.write("1 2 d\n")
+            fd.flush()
+            graph = rustworkx.PyGraph.read_edge_list(fd.name, multigraph=False)
+        self.assertTrue(graph.node_indexes(), [0, 1, 2])
+        self.assertTrue(graph.has_edge(0, 1))
+        self.assertTrue(graph.has_edge(1, 2))
+        self.assertTrue(graph.has_edge(1, 1))
+        self.assertEqual(graph.edges(), [None, "b", "d"])
+        self.assertFalse(graph.multigraph)
+
+    def test_remove_selfloops_graph(self):
+        with tempfile.NamedTemporaryFile("wt") as fd:
+            fd.write("0 1\n")
+            fd.write("1 1 a\n")
+            fd.write("1 1 b\n")
+            fd.write("2 1 c\n")
+            fd.write("1 2 d\n")
+            fd.flush()
+            graph = rustworkx.PyGraph.read_edge_list(fd.name, allow_self_loops=False)
+        self.assertTrue(graph.node_indexes(), [0, 1, 2])
+        self.assertTrue(graph.has_edge(0, 1))
+        self.assertTrue(graph.has_edge(1, 2))
+        self.assertFalse(graph.has_edge(1, 1))
+        self.assertEqual(graph.edges(), [None, "c", "d"])
+
     def test_write_edge_list_empty_digraph(self):
         path = os.path.join(tempfile.gettempdir(), "empty.txt")
         graph = rustworkx.PyGraph()