Avoid requirining new pyfunctions to be declared in lib.rs

CONTRIBUTING.md

@@ -31,11 +31,12 @@ you for an overview of our simplified source tree:
 │ │ └── more_pure_rust_code.rs
 ```
 
-#### Module exports in `lib.rs`
+#### Exporting new functions
 
-To add new functions, you will need to export them in `lib.rs`. `lib.rs` will
-import functions defined in Rust modules (see the next section), and export
-them to Python using `m.add_wrapped(wrap_pyfunction!(your_new_function))?;`
+To add new functions, you will need to export them in the
+`export_rustworkx_functions!` statement in the Rust file you are editing.
+If the function is not added to that statement, the Rust compiler
+will complain about dead-code and Python will not find the function.
 
 #### Adding and changing functions in modules
 
@@ -66,7 +67,9 @@ pub fn your_new_function(
 > __NOTE:__ If you create a new `your_module.rs`, remember to declare and import it in `lib.rs`:
 > ```rust
 > mod your_module;
-> use your_module::*;
+> // more code follows
+> // inside the function named rustworkx
+> your_module::register_rustworkx_functions(m)?;
 > ```
 
 #### Module directories: when a single file is not enough

src/bisimulation.rs

@@ -8,10 +8,12 @@ use hashbrown::hash_map::Entry;
 use hashbrown::{HashMap, HashSet};
 
 use crate::iterators::{IndexPartitionBlock, RelationalCoarsestPartition};
-use crate::{digraph, Directed, StablePyGraph};
+use crate::{digraph, export_rustworkx_functions, Directed, StablePyGraph};
 use petgraph::graph;
 use petgraph::Direction::{Incoming, Outgoing};
 
+export_rustworkx_functions!(digraph_maximum_bisimulation);
+
 type Block = Vec<graph::NodeIndex>;
 type Counterimage = HashMap<graph::NodeIndex, Vec<graph::NodeIndex>>;
 type NodeToBlockVec = Vec<Rc<RefCell<FineBlock>>>;

src/cartesian_product.rs

@@ -11,7 +11,7 @@
 // under the License.
 
 use crate::iterators::ProductNodeMap;
-use crate::{digraph, graph, StablePyGraph};
+use crate::{digraph, export_rustworkx_functions, graph, StablePyGraph};
 
 use hashbrown::HashMap;
 
@@ -21,6 +21,8 @@ use petgraph::{algo, EdgeType};
 use pyo3::prelude::*;
 use pyo3::Python;
 
+export_rustworkx_functions!(graph_cartesian_product, digraph_cartesian_product);
+
 fn cartesian_product<Ty: EdgeType>(
  py: Python,
  first: &StablePyGraph<Ty>,

src/centrality.rs

@@ -15,6 +15,7 @@
 use std::convert::TryFrom;
 
 use crate::digraph;
+use crate::export_rustworkx_functions;
 use crate::graph;
 use crate::iterators::{CentralityMapping, EdgeCentralityMapping};
 use crate::CostFn;
@@ -29,6 +30,19 @@ use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use rustworkx_core::centrality;
 
+export_rustworkx_functions!(
+ graph_betweenness_centrality,
+ digraph_betweenness_centrality,
+ graph_closeness_centrality,
+ digraph_closeness_centrality,
+ graph_edge_betweenness_centrality,
+ digraph_edge_betweenness_centrality,
+ graph_eigenvector_centrality,
+ digraph_eigenvector_centrality,
+ graph_katz_centrality,
+ digraph_katz_centrality
+);
+
 /// Compute the betweenness centrality of all nodes in a PyGraph.
 ///
 /// Betweenness centrality of a node :math:`v` is the sum of the

src/coloring.rs

@@ -11,7 +11,7 @@
 // under the License.
 
 use crate::GraphNotBipartite;
-use crate::{digraph, graph, EdgeIndex, NodeIndex};
+use crate::{digraph, export_rustworkx_functions, graph, EdgeIndex, NodeIndex};
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -27,6 +27,15 @@ use rustworkx_core::coloring::{
 
 pub use rustworkx_core::coloring::ColoringStrategy as ColoringStrategyCore;
 
+export_rustworkx_functions!(
+ graph_greedy_color,
+ graph_misra_gries_edge_color,
+ graph_greedy_edge_color,
+ graph_bipartite_edge_color,
+ graph_two_color,
+ digraph_two_color
+);
+
 /// Greedy coloring strategies available for `graph_greedy_color`
 ///
 /// .. list-table:: Strategy description

src/connectivity/mod.rs

@@ -17,7 +17,8 @@ mod johnson_simple_cycles;
 mod subgraphs;
 
 use super::{
- digraph, get_edge_iter_with_weights, graph, score, weight_callable, InvalidNode, NullGraph,
+ digraph, export_rustworkx_functions, get_edge_iter_with_weights, graph, score, weight_callable,
+ InvalidNode, NullGraph,
 };
 
 use hashbrown::{HashMap, HashSet};
@@ -46,6 +47,43 @@ use rustworkx_core::coloring::two_color;
 use rustworkx_core::connectivity;
 use rustworkx_core::dag_algo::longest_path;
 
+export_rustworkx_functions!(
+ cycle_basis,
+ simple_cycles,
+ strongly_connected_components,
+ digraph_find_cycle,
+ number_connected_components,
+ connected_components,
+ node_connected_component,
+ is_connected,
+ number_weakly_connected_components,
+ weakly_connected_components,
+ is_weakly_connected,
+ is_semi_connected,
+ digraph_adjacency_matrix,
+ graph_adjacency_matrix,
+ graph_complement,
+ digraph_complement,
+ digraph_is_bipartite,
+ graph_is_bipartite,
+ graph_isolates,
+ digraph_isolates,
+ chain_decomposition,
+ biconnected_components,
+ bridges,
+ articulation_points,
+ stoer_wagner_min_cut,
+ graph_all_simple_paths,
+ digraph_all_simple_paths,
+ graph_all_pairs_all_simple_paths,
+ digraph_all_pairs_all_simple_paths,
+ graph_longest_simple_path,
+ digraph_longest_simple_path,
+ graph_core_number,
+ digraph_core_number,
+ connected_subgraphs
+);
+
 /// Return a list of cycles which form a basis for cycles of a given PyGraph
 ///
 /// A basis for cycles of a graph is a minimal collection of

src/dag_algo/mod.rs

@@ -17,7 +17,9 @@ use rustworkx_core::dag_algo::layers as core_layers;
 use rustworkx_core::dictmap::InitWithHasher;
 
 use super::iterators::NodeIndices;
-use crate::{digraph, DAGHasCycle, InvalidNode, RxPyResult, StablePyGraph};
+use crate::{
+ digraph, export_rustworkx_functions, DAGHasCycle, InvalidNode, RxPyResult, StablePyGraph,
+};
 
 use rustworkx_core::dag_algo::collect_bicolor_runs as core_collect_bicolor_runs;
 use rustworkx_core::dag_algo::collect_runs as core_collect_runs;
@@ -37,6 +39,21 @@ use petgraph::visit::NodeIndexable;
 
 use num_traits::{Num, Zero};
 
+export_rustworkx_functions!(
+ dag_longest_path,
+ dag_longest_path_length,
+ dag_weighted_longest_path,
+ dag_weighted_longest_path_length,
+ is_directed_acyclic_graph,
+ transitive_reduction,
+ topological_sort,
+ topological_generations,
+ lexicographical_topological_sort,
+ collect_runs,
+ collect_bicolor_runs,
+ layers
+);
+
 /// Calculate the longest path in a directed acyclic graph (DAG).
 ///
 /// This function interfaces with the Python `PyDiGraph` object to compute the longest path

src/graphml.rs

@@ -33,7 +33,9 @@ use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 use pyo3::PyErr;
 
-use crate::{digraph::PyDiGraph, graph::PyGraph, StablePyGraph};
+use crate::{digraph::PyDiGraph, export_rustworkx_functions, graph::PyGraph, StablePyGraph};
+
+export_rustworkx_functions!(read_graphml);
 
 pub enum Error {
  Xml(String),

src/isomorphism/mod.rs

@@ -14,13 +14,22 @@
 
 mod vf2;
 
-use crate::{digraph, graph};
+use crate::{digraph, export_rustworkx_functions, graph};
 
 use std::cmp::Ordering;
 
 use pyo3::prelude::*;
 use pyo3::Python;
 
+export_rustworkx_functions!(
+ graph_is_isomorphic,
+ digraph_is_isomorphic,
+ graph_is_subgraph_isomorphic,
+ digraph_is_subgraph_isomorphic,
+ digraph_vf2_mapping,
+ graph_vf2_mapping
+);
+
 /// Determine if 2 directed graphs are isomorphic
 ///
 /// This checks if 2 graphs are isomorphic both structurally and also

src/json/mod.rs

@@ -15,12 +15,19 @@ mod node_link_data;
 use std::fs::File;
 use std::io::BufReader;
 
-use crate::{digraph, graph, JSONDeserializationError, StablePyGraph};
+use crate::{digraph, export_rustworkx_functions, graph, JSONDeserializationError, StablePyGraph};
 use petgraph::{algo, Directed, Undirected};
 
 use pyo3::prelude::*;
 use pyo3::Python;
 
+export_rustworkx_functions!(
+ digraph_node_link_json,
+ graph_node_link_json,
+ from_node_link_json_file,
+ parse_node_link_json
+);
+
 /// Parse a node-link format JSON file to generate a graph
 ///
 /// :param path str: The path to the JSON file to load

src/layout/mod.rs

@@ -17,7 +17,7 @@ mod shell;
 mod spiral;
 mod spring;
 
-use crate::{digraph, graph};
+use crate::{digraph, export_rustworkx_functions, graph};
 use spring::Point;
 
 use hashbrown::{HashMap, HashSet};
@@ -27,6 +27,21 @@ use pyo3::Python;
 
 use crate::iterators::Pos2DMapping;
 
+export_rustworkx_functions!(
+ graph_random_layout,
+ digraph_random_layout,
+ graph_bipartite_layout,
+ digraph_bipartite_layout,
+ graph_circular_layout,
+ digraph_circular_layout,
+ graph_shell_layout,
+ digraph_shell_layout,
+ graph_spiral_layout,
+ digraph_spiral_layout,
+ graph_spring_layout,
+ digraph_spring_layout
+);
+
 /// Position nodes using Fruchterman-Reingold force-directed algorithm.
 ///
 /// The algorithm simulates a force-directed representation of the network