Introduce build.rs to reduce boilerplate

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,6 @@ 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::*;
 > ```
 
 #### Module directories: when a single file is not enough

build.rs

@@ -0,0 +1,93 @@
+use std::collections::BTreeSet;
+use std::env;
+use std::fs;
+use std::io::Read;
+use std::io::Write;
+use std::path;
+
+fn main() {
+ let src_dir_path = env::var("CARGO_MANIFEST_DIR").unwrap();
+ let src_dir_path = format!("{}/src/", src_dir_path);
+ let out_dir = fs::read_dir(src_dir_path).expect("could not read src/ directory");
+
+ let mut modules = BTreeSet::new();
+ for entry in out_dir {
+ let entry = entry.expect("could not read entry");
+ let path = entry.path();
+ // Top-level .rs files
+ if path.is_file() {
+ let file_name = path.to_str().unwrap();
+ if file_name.ends_with(".rs") && file_name != "lib.rs" {
+ modules.insert(file_name.to_string());
+ }
+ }
+ if path.is_dir() {
+ let sub_dir = fs::read_dir(path).expect("could not read subdirectory");
+ for entry in sub_dir {
+ let entry = entry.expect("could not read entry");
+ let path = entry.path();
+ if path.is_file() {
+ let file_name = path.to_str().unwrap();
+ if file_name.ends_with("mod.rs") {
+ let module_name = file_name.to_string();
+ modules.insert(module_name);
+ }
+ }
+ }
+ }
+ }
+
+ // Create the generated file with the modules
+ let out_dir = env::var("OUT_DIR").unwrap();
+ let dest_path = path::PathBuf::from(out_dir).join("generated_include_rustworkx_modules.rs");
+
+ // Create the file and write the contents to it
+ let mut f = fs::File::create(dest_path).unwrap();
+
+ let mut rustworkx_modules = BTreeSet::new();
+
+ for path in modules {
+ let mut file = fs::File::open(path.clone())
+ .expect("could not open file to check if it declares a rustworkx module");
+ let mut content = String::new();
+ file.read_to_string(&mut content)
+ .expect("could not read contents of the file");
+ if content.contains("export_rustworkx_functions!") {
+ rustworkx_modules.insert(module_name_from_file_name(path.clone()));
+ }
+ }
+
+ writeln!(f, "fn register_rustworkx_everything(m: &pyo3::Bound<pyo3::types::PyModule>) -> pyo3::prelude::PyResult<()>").expect("could not write function signature");
+ writeln!(f, "{{").expect("could not write function body");
+
+ for module in rustworkx_modules {
+ writeln!(f, "{}::register_rustworkx_functions(m)?;", module.clone())
+ .expect("could not write to file");
+ }
+ writeln!(f, "Ok(())").expect("could not write function body");
+ writeln!(f, "}}").expect("could not write function body");
+}
+
+fn module_name_from_file_name(filename: String) -> String {
+ if filename.ends_with("mod.rs") {
+ let parent = path::Path::new(&filename)
+ .parent()
+ .expect("could not get parent directory");
+ let module_name = parent
+ .file_name()
+ .expect("could not get file name")
+ .to_str()
+ .expect("could not convert to string");
+ return module_name.to_string();
+ }
+ let module_name = path::Path::new(&filename)
+ .file_name()
+ .expect("could not get file name")
+ .to_str()
+ .expect("could not convert to string");
+ return module_name
+ .to_string()
+ .strip_suffix(".rs")
+ .expect("could not strip suffix")
+ .to_string();
+}

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