after running cargo fmt

Author: gluonhiggs

rustworkx-core/src/connectivity/minimum_cycle_basis.rs

@@ -1,10 +1,10 @@
 use crate::connectivity::conn_components::connected_components;
 use crate::dictmap::*;
+use crate::shortest_path::dijkstra;
 use crate::Result;
 use hashbrown::{HashMap, HashSet};
 use petgraph::algo::{astar, min_spanning_tree};
 use petgraph::csr::IndexType;
-use crate::shortest_path::dijkstra;
 use petgraph::data::{DataMap, Element};
 use petgraph::graph::Graph;
 use petgraph::graph::NodeIndex;
@@ -35,20 +35,18 @@ impl EdgeWeightToNumber for i32 {
 
 fn create_subgraphs_from_components<G>(
     graph: G,
-    components: Vec<HashSet<G::NodeId>>
+    components: Vec<HashSet<G::NodeId>>,
 ) -> Vec<(Graph<G::NodeId, i32, Undirected>, HashMap<usize, NodeIndex>)>
 where
-    G:   IntoEdgeReferences
-        + NodeIndexable
-        + IntoNodeIdentifiers,
+    G: IntoEdgeReferences + NodeIndexable + IntoNodeIdentifiers,
     G::NodeId: Eq + Hash,
     G::EdgeWeight: EdgeWeightToNumber,
 {
     components
         .into_iter()
         .map(|component| {
-            let mut subgraph = Graph::<_ ,i32, Undirected>::default();
-            let mut node_subnode_map:HashMap<usize, NodeIndex> = HashMap::new();
+            let mut subgraph = Graph::<_, i32, Undirected>::default();
+            let mut node_subnode_map: HashMap<usize, NodeIndex> = HashMap::new();
             for nodeid in graph.node_identifiers() {
                 if component.contains(&nodeid) {
                     let node = graph.to_index(nodeid);
@@ -66,7 +64,8 @@ where
                 }
             }
             (subgraph, node_subnode_map)
-        }).collect()  
+        })
+        .collect()
 }
 pub fn minimum_cycle_basis<G, E>(graph: G) -> Result<Vec<Vec<NodeIndex>>, E>
 where
@@ -114,20 +113,23 @@ where
         .map(|(index, node_index)| (node_index, index))
         .collect();
     for edge in subgraph.edge_references() {
-        sub_edges.push((
-            node_map[&edge.source()],
-            node_map[&edge.target()],
-        ));
+        sub_edges.push((node_map[&edge.source()], node_map[&edge.target()]));
     }
     let mst = min_spanning_tree(&subgraph);
-    let sub_mst_edges: Vec<_> = mst.filter_map(|element| {
-        if let Element::Edge { source, target, weight: _ } = element {
-            Some((source, target))
+    let sub_mst_edges: Vec<_> = mst
+        .filter_map(|element| {
+            if let Element::Edge {
+                source,
+                target,
+                weight: _,
+            } = element
+            {
+                Some((source, target))
             } else {
-            None
+                None
             }
-            })
-            .collect();
+        })
+        .collect();
 
     let mut chords: Vec<(usize, usize)> = Vec::new();
     for edge in sub_edges.iter() {
@@ -201,7 +203,7 @@ where
 fn _min_cycle<G, F, E>(
     subgraph: G,
     orth: HashSet<(usize, usize)>,
-    mut weight_fn: F
+    mut weight_fn: F,
 ) -> Result<Vec<(usize, usize)>, E>
 where
     G: IntoNodeReferences + IntoEdgeReferences + DataMap + NodeIndexable,
@@ -243,11 +245,13 @@ where
     let mut shortest_path_map: HashMap<G::NodeId, i32> = HashMap::new();
     for nodeid in subgraph.node_identifiers() {
         let (node, lifted_node) = subgraph_gi_map[&nodeid];
-        let result: Result<DictMap<NodeIndex, i32>> = dijkstra(&gi, 
-            node, 
-            Some(lifted_node), 
+        let result: Result<DictMap<NodeIndex, i32>> = dijkstra(
+            &gi,
+            node,
+            Some(lifted_node),
             |e| Ok(*e.weight() as i32),
-            None);
+            None,
+        );
         // Find the shortest distance in the result and store it in the shortest_path_map
         let spl = result.unwrap()[&lifted_node];
         shortest_path_map.insert(nodeid, spl);
@@ -301,16 +305,13 @@ where
     Ok(min_edgelist)
 }
 
-
-
 #[cfg(test)]
 mod test_minimum_cycle_basis {
 
     use crate::connectivity::minimum_cycle_basis::minimum_cycle_basis;
     use petgraph::graph::{Graph, NodeIndex};
     use petgraph::Undirected;
 
-
     #[test]
     fn test_empty_graph() {
         let graph: Graph<String, i32> = Graph::new();

src/connectivity/mod.rs

@@ -22,10 +22,10 @@ use super::{
 
 use hashbrown::{HashMap, HashSet};
 
-use petgraph::algo;
 use petgraph::stable_graph::NodeIndex;
 use petgraph::unionfind::UnionFind;
 use petgraph::visit::{EdgeRef, IntoEdgeReferences, NodeCount, NodeIndexable, Visitable};
+use petgraph::{algo, Graph};
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;