diff --git a/docs/source/api/generators.rst b/docs/source/api/generators.rst
index d6d630d13c..2f930704c7 100644
--- a/docs/source/api/generators.rst
+++ b/docs/source/api/generators.rst
@@ -33,3 +33,4 @@ Generators
     rustworkx.generators.complete_graph
     rustworkx.generators.directed_complete_graph
     rustworkx.generators.dorogovtsev_goltsev_mendes_graph
+    rustworkx.generators.karate_club_graph
diff --git a/src/generators.rs b/src/generators.rs
index ade905e2b3..40c5ae0ad8 100644
--- a/src/generators.rs
+++ b/src/generators.rs
@@ -23,14 +23,14 @@ use pyo3::Python;
 use super::{digraph, graph, StablePyGraph};
 use rustworkx_core::generators as core_generators;
 
-/// Generate an undirected cycle graph
+/// Generate an undirected cycle graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
-///     will be the center node of the cycle graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -76,14 +76,14 @@ pub fn cycle_graph(
     })
 }
 
-/// Generate a directed cycle graph
+/// Generate a directed cycle graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
-///     will be the center node of the cycle graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool bidirectional: Adds edges in both directions between two nodes
 ///     if set to ``True``. Default value is ``False``
 /// :param bool multigraph: When set to ``False`` the output
@@ -139,14 +139,14 @@ pub fn directed_cycle_graph(
     })
 }
 
-/// Generate an undirected path graph
+/// Generate an undirected path graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
-///     will be the center node of the path graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -192,14 +192,14 @@ pub fn path_graph(
     })
 }
 
-/// Generate a directed path graph
+/// Generate a directed path graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
-///     will be the center node of the path graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool bidirectional: Adds edges in both directions between two nodes
 ///     if set to ``True``. Default value is ``False``
 /// :param bool multigraph: When set to ``False`` the output
@@ -255,20 +255,20 @@ pub fn directed_path_graph(
     })
 }
 
-/// Generate an undirected star graph
+/// Generate an undirected star graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     The first element in the list
 ///     will be the center node of the star graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
 ///
-///
 /// :returns: The generated star graph
 /// :rtype: PyGraph
 /// :raises IndexError: If neither ``num_nodes`` or ``weights`` are specified
@@ -310,15 +310,16 @@ pub fn star_graph(
     })
 }
 
-/// Generate a directed star graph
+/// Generate a directed star graph.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights, the first element in the list
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     The first element in the list
 ///     will be the center node of the star graph. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param bool inward: If set ``True`` the nodes will be directed towards the
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param bool inward: If set to ``True``, the nodes will be directed towards the
 ///     center node. This parameter is ignored if ``bidirectional`` is set to
 ///     ``True``.
 /// :param bool bidirectional: Adds edges in both directions between two nodes
@@ -386,13 +387,14 @@ pub fn directed_star_graph(
     })
 }
 
-/// Generate an undirected mesh (complete) graph where every node is connected to every other
+/// Generate an undirected mesh (complete) graph where every node is connected to every other.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -423,13 +425,14 @@ pub fn mesh_graph(
     complete_graph(py, num_nodes, weights, multigraph)
 }
 
-/// Generate a directed mesh (complete) graph where every node is connected to every other
+/// Generate a directed mesh (complete) graph where every node is connected to every other.
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -465,16 +468,17 @@ pub fn directed_mesh_graph(
 /// :param int rows: The number of rows to generate the graph with.
 ///     If specified, ``cols`` also need to be specified
 /// :param int cols: The number of cols to generate the graph with.
-///     If specified, ``rows`` also need to be specified. rows*cols
+///     If specified, ``rows`` also need to be specified. ``rows * cols``
 ///     defines the number of nodes in the graph
-/// :param list weights: A list of node weights. Nodes are filled row wise.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     Nodes are filled row wise.
 ///     If rows and cols are not specified, then a linear graph containing
 ///     all the values in weights list is created.
-///     If number of nodes(rows*cols) is less than length of
+///     If number of nodes (``rows * cols``) is less than length of
 ///     weights list, the trailing weights are ignored.
-///     If number of nodes(rows*cols) is greater than length of
+///     If number of nodes (``rows * cols``) is greater than length of
 ///     weights list, extra nodes with None weight are appended.
-/// :param bool multigraph: When set to ``False`` the output
+/// :param bool multigraph: When set to ``False``, the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
@@ -523,17 +527,18 @@ pub fn grid_graph(
 ///
 /// :param int rows: The number of rows to generate the graph with.
 ///     If specified, ``cols`` also need to be specified.
-/// :param int cols: The number of cols to generate the graph with.
-///     If specified, ``rows`` also need to be specified. rows*cols
+/// :param int cols: The number of columns to generate the graph with.
+///     If specified, ``rows`` also need to be specified. ``rows * cols``
 ///     defines the number of nodes in the graph.
-/// :param list weights: A list of node weights. Nodes are filled row wise.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     Nodes are filled row wise.
 ///     If rows and cols are not specified, then a linear graph containing
 ///     all the values in weights list is created.
-///     If number of nodes(rows*cols) is less than length of
+///     If number of nodes(``rows * cols``) is less than length of
 ///     weights list, the trailing weights are ignored.
-///     If number of nodes(rows*cols) is greater than length of
+///     If number of nodes(``rows * cols``) is greater than length of
 ///     weights list, extra nodes with None weight are appended.
-/// :param bidirectional: A parameter to indicate if edges should exist in
+/// :param bool bidirectional: A parameter to indicate if edges should exist in
 ///     both directions between nodes. Defaults to ``False``.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
@@ -617,10 +622,10 @@ pub fn directed_grid_graph(
 ///   This function implements Fig 10.b left of the `paper <https://arxiv.org/abs/1907.09528>`_.
 ///   This function doesn't support the variant Fig 10.b right.
 ///
-/// Note that if ``d`` is set to ``1`` a :class:`~rustworkx.PyGraph` with a
+/// Note that if ``d`` is set to ``1``, a :class:`~rustworkx.PyGraph` with a
 /// single node will be returned.
 ///
-/// :param int d: distance of the code. If ``d`` is set to ``1`` a
+/// :param int d: distance of the code. If ``d`` is set to ``1``, a
 ///     :class:`~rustworkx.PyGraph` with a single node will be returned. ``d`` must be
 ///     an odd number.
 /// :param bool multigraph: When set to ``False`` the output
@@ -630,7 +635,7 @@ pub fn directed_grid_graph(
 ///
 /// :returns: The generated heavy square graph
 /// :rtype: PyGraph
-/// :raises IndexError: If d is even.
+/// :raises IndexError: If ``d`` is even
 ///
 /// .. jupyter-execute::
 ///
@@ -690,10 +695,10 @@ pub fn heavy_square_graph(py: Python, d: usize, multigraph: bool) -> PyResult<gr
 ///   This function implements Fig 10.b left of the `paper <https://arxiv.org/abs/1907.09528>`_.
 ///   This function doesn't support the variant Fig 10.b right.
 ///
-/// :param int d: distance of the code. If ``d`` is set to ``1`` a
+/// :param int d: distance of the code. If ``d`` is set to ``1``, a
 ///     :class:`~rustworkx.PyDiGraph` with a single node will be returned. ``d`` must be
 ///     an odd number.
-/// :param bidirectional: A parameter to indicate if edges should exist in
+/// :param bool bidirectional: A parameter to indicate if edges should exist in
 ///     both directions between nodes. Defaults to ``False``.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
@@ -702,7 +707,7 @@ pub fn heavy_square_graph(py: Python, d: usize, multigraph: bool) -> PyResult<gr
 ///
 /// :returns: The generated directed heavy square graph
 /// :rtype: PyDiGraph
-/// :raises IndexError: If d is even.
+/// :raises IndexError: If ``d`` is even
 ///
 /// .. jupyter-execute::
 ///
@@ -777,10 +782,10 @@ pub fn directed_heavy_square_graph(
 ///     ... D   D-S-D ...
 ///
 ///
-/// :param int d: distance of the code. If ``d`` is set to ``1`` a
+/// :param int d: distance of the code. If ``d`` is set to ``1``, a
 ///     :class:`~rustworkx.PyGraph` with a single node will be returned.
 ///     ``d`` must be an odd number.
-/// :param bidirectional: A parameter to indicate if edges should exist in
+/// :param bool bidirectional: A parameter to indicate if edges should exist in
 ///     both directions between nodes. Defaults to ``False``.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
@@ -789,7 +794,7 @@ pub fn directed_heavy_square_graph(
 ///
 /// :returns: The generated heavy hex graph
 /// :rtype: PyGraph
-/// :raises IndexError: If d is even.
+/// :raises IndexError: If ``d`` is even
 ///
 /// .. jupyter-execute::
 ///
@@ -857,7 +862,7 @@ pub fn heavy_hex_graph(py: Python, d: usize, multigraph: bool) -> PyResult<graph
 ///     ... D   D-S-D ...
 ///
 ///
-/// :param int d: distance of the code. If ``d`` is set to ``1`` a
+/// :param int d: distance of the code. If ``d`` is set to ``1``, a
 ///     :class:`~rustworkx.PyDiGraph` with a single node will be returned.
 ///     ``d`` must be an odd number.
 /// :param bool multigraph: When set to ``False`` the output
@@ -867,7 +872,7 @@ pub fn heavy_hex_graph(py: Python, d: usize, multigraph: bool) -> PyResult<graph
 ///
 /// :returns: The generated heavy hex directed graph
 /// :rtype: PyDiGraph
-/// :raises IndexError: If d is even.
+/// :raises IndexError: If ``d`` is even.
 ///
 /// .. jupyter-execute::
 ///
@@ -910,24 +915,25 @@ const MAX_ORDER: u32 = 60;
 #[cfg(not(target_pointer_width = "64"))]
 const MAX_ORDER: u32 = 29;
 
-/// Generate an undirected binomial tree of order n recursively.
+/// Generate an undirected binomial tree of order `n` recursively.
 ///
 /// :param int order: Order of the binomial tree. The maximum allowed value
-///     for order on the platform your running on. If it's a 64bit platform
+///     for order on the platform your running on. If it's a 64bit platform,
 ///     the max value is 60 and on 32bit systems the max value is 29. Any order
 ///     value above these will raise an ``OverflowError``.
-/// :param list weights: A list of node weights. If the number of weights is
-///     less than 2**order, extra nodes with None will be appended.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If the number of weights is
+///     less than ``2**order``, extra nodes with None will be appended.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead calls which would
 ///     create a parallel edge will update the existing edge.
 ///
-/// :returns: A binomial tree with 2^n vertices and 2^n - 1 edges.
+/// :returns: A binomial tree with `2^n` vertices and `2^n - 1` edges
 /// :rtype: PyGraph
 /// :raises IndexError: If the length of ``weights`` is greater that 2^n
 /// :raises OverflowError: If the input order exceeds the maximum value for the
-///     current platform.
+///     current platform
 ///
 /// .. jupyter-execute::
 ///
@@ -971,28 +977,29 @@ pub fn binomial_tree_graph(
     })
 }
 
-/// Generate a directed binomial tree of order n recursively.
+/// Generate a directed binomial tree of order `n` recursively.
 ///
 /// The edges propagate towards right and bottom direction if ``bidirectional`` is ``False``
 ///
 /// :param int order: Order of the binomial tree. The maximum allowed value
-///     for order on the platform your running on. If it's a 64bit platform
+///     for order on the platform your running on. If it's a 64bit platform,
 ///     the max value is 60 and on 32bit systems the max value is 29. Any order
 ///     value above these will raise an ``OverflowError``.
-/// :param list weights: A list of node weights. If the number of weights is
-///     less than 2**order, extra nodes with None will be appended.
-/// :param bidirectional: A parameter to indicate if edges should exist in
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If the number of weights is
+///     less than ``2**order``, extra nodes with None will be appended.
+/// :param bool bidirectional: A parameter to indicate if edges should exist in
 ///     both directions between nodes. Defaults to ``False``.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
 ///
-/// :returns: A directed binomial tree with 2^n vertices and 2^n - 1 edges.
+/// :returns: A directed binomial tree with `2^n` vertices and `2^n - 1` edges
 /// :rtype: PyDiGraph
-/// :raises IndexError: If the length of ``weights`` is greater that 2^n
+/// :raises IndexError: If the length of ``weights`` is greater that `2^n`
 /// :raises OverflowError: If the input order exceeds the maximum value for the
-///     current platform.
+///     current platform
 ///
 /// .. jupyter-execute::
 ///
@@ -1048,9 +1055,10 @@ pub fn directed_binomial_tree_graph(
 ///
 /// Sometimes called a k-ary, n-ary, or m-ary tree.
 ///
-/// :param int branching factor: The number of children at each node.
-/// :param int num_nodes: The number of nodes in the graph.
-/// :param list weights: A list of node weights. If the number of weights is
+/// :param int branching factor: The number of children at each node
+/// :param int num_nodes: The number of nodes in the graph
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If the number of weights is
 ///     less than ``num_nodes``, extra nodes with None will be appended. The
 ///     number of weights cannot exceed num_nodes.
 /// :param bool multigraph: When set to ``False`` the output
@@ -1058,9 +1066,9 @@ pub fn directed_binomial_tree_graph(
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
 ///
-/// :returns: A r-ary tree.
+/// :returns: A r-ary tree
 /// :rtype: PyGraph
-/// :raises IndexError: If the length of ``weights`` is greater that n
+/// :raises IndexError: If the length of ``weights`` is greater that ``num_nodes``
 ///
 /// .. jupyter-execute::
 ///
@@ -1112,24 +1120,22 @@ fn _hexagonal_lattice_node_position(u: usize, v: usize) -> (f64, f64) {
 
 /// Generate an undirected hexagonal lattice graph.
 ///
-/// :param int rows: The number of rows to generate the graph with.
-/// :param int cols: The number of columns to generate the graph with.
-/// :param bool multigraph: When set to ``False`` the output
+/// :param int rows: The number of rows to generate the graph with
+/// :param int cols: The number of columns to generate the graph with
+/// :param bool multigraph: When set to ``False``, the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
-/// :param bool periodic: When set to ``True`` the boundaries of the lattice
+/// :param bool periodic: When set to ``True``, the boundaries of the lattice
 ///     will be joined to form a periodic grid. Requires ``cols`` to be even,
 ///     ``rows > 1``, and ``cols > 1``.
 /// :param bool with_positions: When set to ``True`` each node will be assigned
 ///     a pair of coordinates ``(x, y)`` as a weight. This embeds the nodes in
 ///     the plane so that each hexagon is regular (with side length 1).
 ///
-/// :returns: The generated hexagonal lattice graph.
-///
+/// :returns: The generated hexagonal lattice graph
 /// :rtype: PyGraph
-/// :raises TypeError: If either ``rows`` or ``cols`` are
-///      not specified
+/// :raises TypeError: If either ``rows`` or ``cols`` are not specified
 ///
 /// .. jupyter-execute::
 ///
@@ -1190,8 +1196,8 @@ pub fn hexagonal_lattice_graph(
 /// The edges propagate towards right and bottom direction if ``bidirectional`` is ``False``
 ///
 /// :param int rows: The number of rows to generate the graph with.
-/// :param int cols: The number of rows to generate the graph with.
-/// :param bidirectional: A parameter to indicate if edges should exist in
+/// :param int cols: The number of columns to generate the graph with.
+/// :param bool bidirectional: A parameter to indicate if edges should exist in
 ///     both directions between nodes. Defaults to ``False``.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
@@ -1204,11 +1210,9 @@ pub fn hexagonal_lattice_graph(
 ///     a pair of coordinates ``(x, y)`` as a payload. This embeds the nodes in
 ///     the plane so that each hexagon is regular (with side length 1).
 ///
-/// :returns: The generated directed hexagonal lattice graph.
-///
+/// :returns: The generated directed hexagonal lattice graph
 /// :rtype: PyDiGraph
-/// :raises TypeError: If either ``rows`` or ``cols`` are
-///      not specified
+/// :raises TypeError: If either ``rows`` or ``cols`` are not specified
 ///
 /// .. jupyter-execute::
 ///
@@ -1276,22 +1280,24 @@ pub fn directed_hexagonal_lattice_graph(
 /// path.
 ///
 /// If neither ``num_path_nodes`` nor ``path_weights`` (both described
-/// below) are specified then this is equivalent to
+/// below) are specified, then this is equivalent to
 /// :func:`~rustworkx.generators.complete_graph`
 ///
 /// :param int num_mesh_nodes: The number of nodes to generate the mesh graph
 ///     with. Node weights will be None if this is specified. If both
-///     ``num_mesh_nodes`` and ``mesh_weights`` are set this will be ignored and
+///     ``num_mesh_nodes`` and ``mesh_weights`` are set, this will be ignored and
 ///     ``mesh_weights`` will be used.
 /// :param int num_path_nodes: The number of nodes to generate the path
 ///     with. Node weights will be None if this is specified. If both
-///     ``num_path_nodes`` and ``path_weights`` are set this will be ignored and
+///     ``num_path_nodes`` and ``path_weights`` are set, this will be ignored and
 ///     ``path_weights`` will be used.
-/// :param list mesh_weights: A list of node weights for the mesh graph. If both
-///     ``num_mesh_nodes`` and ``mesh_weights`` are set ``num_mesh_nodes`` will
+/// :param Sequence[Any] mesh_weights: A sequence of node weights for the mesh graph,
+///     typically a list. If both
+///     ``num_mesh_nodes`` and ``mesh_weights`` are set, ``num_mesh_nodes`` will
 ///     be ignored and ``mesh_weights`` will be used.
-/// :param list path_weights: A list of node weights for the path. If both
-///     ``num_path_nodes`` and ``path_weights`` are set ``num_path_nodes`` will
+/// :param Sequence[Any] path_weights: A sequence of node weights for the path,
+///     typically a list. If both
+///     ``num_path_nodes`` and ``path_weights`` are set, ``num_path_nodes`` will
 ///     be ignored and ``path_weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
@@ -1354,21 +1360,23 @@ pub fn lollipop_graph(
 ///
 /// :param int num_mesh_nodes: The number of nodes to generate the mesh graphs
 ///     with. Node weights will be None if this is specified. If both
-///     ``num_mesh_nodes`` and ``mesh_weights`` are set this will be ignored and
+///     ``num_mesh_nodes`` and ``mesh_weights`` are set, this will be ignored and
 ///     ``mesh_weights`` will be used.
 /// :param int num_path_nodes: The number of nodes to generate the path
 ///     with. Node weights will be None if this is specified. If both
-///     ``num_path_nodes`` and ``path_weights`` are set this will be ignored and
+///     ``num_path_nodes`` and ``path_weights`` are set, this will be ignored and
 ///     ``path_weights`` will be used.
-/// :param bool multigraph: When set to ``False`` the output
+/// :param bool multigraph: When set to ``False``, the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
-/// :param list mesh_weights: A list of node weights for the mesh graph. If both
-///     ``num_mesh_nodes`` and ``mesh_weights`` are set ``num_mesh_nodes`` will
+/// :param Sequence[Any] mesh_weights: A sequence of node weights for the path,
+///     typically a list. If both
+///     ``num_mesh_nodes`` and ``mesh_weights`` are set, ``num_mesh_nodes`` will
 ///     be ignored and ``mesh_weights`` will be used.
-/// :param list path_weights: A list of node weights for the path. If both
-///     ``num_path_nodes`` and ``path_weights`` are set ``num_path_nodes`` will
+/// :param Sequence[Any] path_weights: A sequence of node weights for the path,
+///     typically a list. If both
+///     ``num_path_nodes`` and ``path_weights`` are set, ``num_path_nodes`` will
 ///     be ignored and ``path_weights`` will be used.
 ///
 /// :returns: The generated barbell graph
@@ -1433,13 +1441,10 @@ pub fn barbell_graph(
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
 ///
-/// :returns: The generated generalized Petersen graph.
-///
+/// :returns: The generated generalized Petersen graph
 /// :rtype: PyGraph
-/// :raises IndexError: If either ``n`` or ``k`` are
-///      not valid
-/// :raises TypeError: If either ``n`` or ``k`` are
-///      not non-negative integers
+/// :raises IndexError: If either ``n`` or ``k`` are not valid
+/// :raises TypeError: If either ``n`` or ``k`` are not non-negative integers
 ///
 /// .. jupyter-execute::
 ///   
@@ -1495,7 +1500,7 @@ pub fn generalized_petersen_graph(
 
 /// Generate an undirected empty graph with ``n`` nodes and no edges.
 ///
-/// :param int n: The number of nodes to generate the graph with.
+/// :param int n: The number of nodes to generate the graph with
 ///
 /// :returns: The generated empty graph
 /// :rtype: PyGraph
@@ -1527,7 +1532,7 @@ pub fn empty_graph(py: Python, n: usize, multigraph: bool) -> PyResult<graph::Py
 
 /// Generate a directed empty graph with ``n`` nodes and no edges.
 ///
-/// :param int n: The number of nodes to generate the graph with.
+/// :param int n: The number of nodes to generate the graph with
 ///
 /// :returns: The generated empty graph
 /// :rtype: PyDiGraph
@@ -1573,9 +1578,10 @@ pub fn directed_empty_graph(
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -1631,9 +1637,10 @@ pub fn complete_graph(
 ///
 /// :param int num_nodes: The number of nodes to generate the graph with. Node
 ///     weights will be None if this is specified. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
-/// :param list weights: A list of node weights. If both ``num_nodes`` and
-///     ``weights`` are set this will be ignored and ``weights`` will be used.
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
+/// :param Sequence[Any] weights: A sequence of node weights, typically a list.
+///     If both ``num_nodes`` and
+///     ``weights`` are set, this will be ignored and ``weights`` will be used.
 /// :param bool multigraph: When set to ``False`` the output
 ///     :class:`~rustworkx.PyDiGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
@@ -1690,7 +1697,6 @@ pub fn directed_complete_graph(
 /// :param int n: The number of iterations to perform.
 ///
 /// :returns: The generated Dorogovtsev-Goltsev-Mendes graph
-///
 /// :rtype: PyGraph
 ///
 /// .. jupyter-execute::
@@ -1732,14 +1738,13 @@ pub fn dorogovtsev_goltsev_mendes_graph(py: Python, n: usize) -> PyResult<graph:
 /// (interactions). Each node represents a club member, and each edge represents
 /// a relationship between two members.
 ///
-/// :param bool multigraph: When set to ``False`` the output
+/// :param bool multigraph: When set to ``False``, the output
 ///     :class:`~rustworkx.PyGraph` object will not be not be a multigraph and
 ///     won't allow parallel edges to be added. Instead
 ///     calls which would create a parallel edge will update the existing edge.
 ///
 /// :returns: The undirected graph representing the Karate club graph.
 ///           Each node is labeled according to its assigned faction.
-///
 /// :rtype: PyGraph
 ///
 /// .. jupyter-execute::
@@ -1752,8 +1757,8 @@ pub fn dorogovtsev_goltsev_mendes_graph(py: Python, n: usize) -> PyResult<graph:
 ///   mpl_draw(graph, pos=layout)
 ///   
 /// .. [1] Zachary, Wayne W.
-///    "An information flow model for conflict and fission in small groups"
-///    Journal of Anthropological Research, 33, 452-473.
+///     "An information flow model for conflict and fission in small groups"
+///     Journal of Anthropological Research, 33, 452-473.
 ///     https://doi.org/10.1086/jar.33.4.3629752
 #[pyfunction]
 #[pyo3(