Fix some typos in docs and test function names (Qiskit#1398)

Author: eumiro

rustworkx-core/src/bipartite_coloring.rs

@@ -178,7 +178,7 @@ fn euler_cycles(input_graph: &EdgedGraph) -> Vec<Vec<EdgeIndex>> {
 }
 
 /// Splits a regular bipartite multigraph g of even degree 2k into two regular
-/// bipartte multigraphs h0 and h1 of degree k.
+/// bipartite multigraphs h0 and h1 of degree k.
 fn rbmg_split_into_two(
     g: &RegularBipartiteMultiGraph,
 ) -> (RegularBipartiteMultiGraph, RegularBipartiteMultiGraph) {
@@ -904,7 +904,7 @@ mod test_bipartite_coloring {
             match bipartite_edge_color(&graph) {
                 Ok(edge_coloring) => {
                     check_edge_coloring_undirected(&graph, &edge_coloring, Some(3));
-                    // check_bipatite_edge_coloring_is_valid(&graph, &edge_coloring, Some(3));
+                    // check_bipartite_edge_coloring_is_valid(&graph, &edge_coloring, Some(3));
                 }
                 Err(_) => panic!("This should error"),
             }

rustworkx/__init__.py

@@ -123,7 +123,7 @@ class PyDAG(PyDiGraph):
 
     :param bool check_cycle: When this is set to ``True`` the created
         ``PyDAG`` has runtime cycle detection enabled.
-    :param bool multgraph: When this is set to ``False`` the created
+    :param bool multigraph: When this is set to ``False`` the created
         ``PyDAG`` object will not be a multigraph. When ``False`` if a method
         call is made that would add parallel edges the weight/weight from
         that method call will be used to update the existing edge in place.

rustworkx/rustworkx.pyi

@@ -359,7 +359,7 @@ class TopologicalSorter:
     def get_ready(self) -> list[int]: ...
     def done(self, nodes: int | Sequence[int]) -> None: ...
 
-# isomorpism
+# isomorphism
 
 def digraph_is_isomorphic(
     first: PyDiGraph[_S, _T],

src/graph.rs

@@ -1610,7 +1610,7 @@ impl PyGraph {
     ///     single node weight/data object and return a new node weight/data
     ///     object that will be used when adding an node from other onto this
     ///     graph.
-    /// :param Callable edge_map_func: An optional python callabble that will take in a
+    /// :param Callable edge_map_func: An optional python callable that will take in a
     ///     single edge weight/data object and return a new edge weight/data
     ///     object that will be used when adding an edge from other onto this
     ///     graph.

src/graphml.rs

@@ -728,7 +728,7 @@ impl GraphML {
 ///
 /// .. note::
 ///
-///     This implementation does not support mixed graphs (directed and unidirected edges together),
+///     This implementation does not support mixed graphs (directed and undirected edges together),
 ///     hyperedges, nested graphs, or ports.
 ///
 /// .. note::

src/iterators.rs

@@ -1163,8 +1163,8 @@ custom_vec_iter_impl!(
         a_partition_block = partition[0]
         # Use as iterator
         partition_iter = iter(partition)
-        another_block = next(parititon_iter)
-        the_second_block = next(parititon_iter)
+        another_block = next(partition_iter)
+        the_second_block = next(partition_iter)
     "
 );
 impl PyGCProtocol for RelationalCoarsestPartition {}

src/matching/mod.rs

@@ -56,7 +56,7 @@ use crate::weight_callable;
 ///     solution is optimum. If set to true an exception will be raised if
 ///     the found solution is not optimum. This is mostly useful for testing.
 ///
-/// :returns: A set of tuples ofthe matching, Note that only a single
+/// :returns: A set of tuples of the matching, Note that only a single
 ///     direction will be listed in the output, for example:
 ///     ``{(0, 1),}``.
 /// :rtype: set

src/shortest_path/mod.rs

@@ -792,7 +792,7 @@ pub fn graph_astar_shortest_path(
 /// :param int start: The node index to find the shortest paths from
 /// :param int k: The kth shortest path to find the lengths of
 /// :param edge_cost: A python callable that will receive an edge payload and
-///     return a float for the cost of that eedge
+///     return a float for the cost of that edge
 /// :param int goal: An optional goal node index, if specified the output
 ///     dictionary
 ///
@@ -852,7 +852,7 @@ pub fn digraph_k_shortest_path_lengths(
 /// :param int start: The node index to find the shortest paths from
 /// :param int k: The kth shortest path to find the lengths of
 /// :param edge_cost: A python callable that will receive an edge payload and
-///     return a float for the cost of that eedge
+///     return a float for the cost of that edge
 /// :param int goal: An optional goal node index, if specified the output
 ///     dictionary
 ///

tests/digraph/test_bipartite.py

@@ -40,21 +40,21 @@ def test_is_bipartite_with_isolates(self):
         graph.add_nodes_from(range(3))
         self.assertTrue(rustworkx.is_bipartite(graph))
 
-    def test_two_colors_not_biparite_with_isolates(self):
+    def test_two_colors_not_bipartite_with_isolates(self):
         graph = rustworkx.generators.directed_complete_graph(5)
         graph.add_nodes_from(range(3))
         self.assertIsNone(rustworkx.two_color(graph))
 
-    def test_not_biparite_with_isolates(self):
+    def test_not_bipartite_with_isolates(self):
         graph = rustworkx.generators.directed_complete_graph(5)
         graph.add_nodes_from(range(3))
         self.assertFalse(rustworkx.is_bipartite(graph))
 
-    def test_not_biparite(self):
+    def test_not_bipartite(self):
         graph = rustworkx.generators.directed_complete_graph(5)
         self.assertFalse(rustworkx.is_bipartite(graph))
 
-    def test_two_color_not_biparite(self):
+    def test_two_color_not_bipartite(self):
         graph = rustworkx.generators.directed_complete_graph(5)
         self.assertIsNone(rustworkx.two_color(graph))
 

tests/digraph/test_nodes.py

@@ -243,7 +243,7 @@ def test_remove_nodes_retain_edges_by_id_broadcast(self):
             (nodes["d"], nodes["f"], weights[1]),
         }
 
-        # 2:2 broadacst
+        # 2:2 broadcast
         dag.add_edge(nodes["g"], mid, weights[2])
         dag.add_edge(nodes["h"], mid, weights[2])
         dag.add_edge(mid, nodes["i"], weights[2])
@@ -316,7 +316,7 @@ def test_remove_nodes_retain_edges_by_key_broadcast_mod_map(self):
         expected_edges[nodes["d"], nodes["e"]] = allowed_weights
         expected_edges[nodes["d"], nodes["f"]] = allowed_weights
 
-        # 2:2 broadacst
+        # 2:2 broadcast
         dag.add_edge(nodes["g"], mid, 12)
         dag.add_edge(nodes["h"], mid, 22)
         dag.add_edge(mid, nodes["i"], 32)