Python-EasyGraph 1.6__tar.gz → 1.6.1__tar.gz

{python_easygraph-1.6/Python_EasyGraph.egg-info → python_easygraph-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Python-EasyGraph
-Version: 1.6
+Version: 1.6.1
 Summary: Easy Graph
 Home-page: https://github.com/easy-graph/Easy-Graph
 Author: Fudan DataNET Group
@@ -36,6 +36,7 @@ Requires-Dist: pandas>=1.1.0; python_version >= "3.8" and python_version < "3.14
 Requires-Dist: matplotlib
 Requires-Dist: requests
 Requires-Dist: optuna
+Requires-Dist: fastjsonschema
 Provides-Extra: torch
 Requires-Dist: torch>=2.0; extra == "torch"
 Requires-Dist: fastjsonschema; extra == "torch"
@@ -117,10 +118,11 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
-- [01-01-2026] EasyGraph **v1.5.3** released (The Hypergraph Interchange Format (HIF) standard)
+- [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
+- **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
+- [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))
 - [11-23-2025] EasyGraph **v1.5.2** released (LS algorithm for effective community detection)
 - [10-11-2025] EasyGraph **v1.5.1** released (Python 3.14 supported)
-- **[09-29-2025] 🎉 900K+ Downloads! Thanks to our amazing community!**
 - [07-27-2025] EasyGraph **v1.5** released (This version integrates the HWNN model and supports 11 representative network datasets)
 - **[06-29-2025] 🎉 800K+ Downloads!**
 - [11-22-2024] EasyGraph **v1.4.1** released (Python 3.13 supported)

{python_easygraph-1.6 → python_easygraph-1.6.1/Python_EasyGraph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Python-EasyGraph
-Version: 1.6
+Version: 1.6.1
 Summary: Easy Graph
 Home-page: https://github.com/easy-graph/Easy-Graph
 Author: Fudan DataNET Group
@@ -36,6 +36,7 @@ Requires-Dist: pandas>=1.1.0; python_version >= "3.8" and python_version < "3.14
 Requires-Dist: matplotlib
 Requires-Dist: requests
 Requires-Dist: optuna
+Requires-Dist: fastjsonschema
 Provides-Extra: torch
 Requires-Dist: torch>=2.0; extra == "torch"
 Requires-Dist: fastjsonschema; extra == "torch"
@@ -117,10 +118,11 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
-- [01-01-2026] EasyGraph **v1.5.3** released (The Hypergraph Interchange Format (HIF) standard)
+- [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
+- **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
+- [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))
 - [11-23-2025] EasyGraph **v1.5.2** released (LS algorithm for effective community detection)
 - [10-11-2025] EasyGraph **v1.5.1** released (Python 3.14 supported)
-- **[09-29-2025] 🎉 900K+ Downloads! Thanks to our amazing community!**
 - [07-27-2025] EasyGraph **v1.5** released (This version integrates the HWNN model and supports 11 representative network datasets)
 - **[06-29-2025] 🎉 800K+ Downloads!**
 - [11-22-2024] EasyGraph **v1.4.1** released (Python 3.13 supported)

{python_easygraph-1.6 → python_easygraph-1.6.1}/Python_EasyGraph.egg-info/SOURCES.txt

@@ -54,6 +54,8 @@ cpp_easygraph/functions/pagerank/__init__.h
 cpp_easygraph/functions/pagerank/pagerank.cpp
 cpp_easygraph/functions/pagerank/pagerank.h
 cpp_easygraph/functions/path/__init__.h
+cpp_easygraph/functions/path/average_shortest_path_length.cpp
+cpp_easygraph/functions/path/diameter.cpp
 cpp_easygraph/functions/path/mst.cpp
 cpp_easygraph/functions/path/mst.h
 cpp_easygraph/functions/path/path.cpp

{python_easygraph-1.6 → python_easygraph-1.6.1}/Python_EasyGraph.egg-info/requires.txt

@@ -7,6 +7,7 @@ nose>=0.10.1
 matplotlib
 requests
 optuna
+fastjsonschema
 
 [:python_version < "3.14"]
 numpy>=1.23

{python_easygraph-1.6 → python_easygraph-1.6.1}/README.md

@@ -63,10 +63,11 @@ It bridges the gap between EasyGraph and higher-order relationships. EasyHypergr
 - [11-04-2023] [EasyGraph：多功能、跨平台、高效率的跨学科网络分析库 (in Chinese)](https://swarma.org/?p=46252)
 
 ## 🚀 Releases & Milestones
-- [01-01-2026] EasyGraph **v1.5.3** released (The Hypergraph Interchange Format (HIF) standard)
+- [02-01-2026] EasyGraph **v1.6** released (OpenMP-powered functions for large network analysis)
+- **[01-16-2026] 🎉 1M Downloads! Thanks to our amazing community!**
+- [01-01-2026] EasyGraph **v1.5.3** released ([The Hypergraph Interchange Format (HIF) standard](https://github.com/HIF-org/HIF-standard))
 - [11-23-2025] EasyGraph **v1.5.2** released (LS algorithm for effective community detection)
 - [10-11-2025] EasyGraph **v1.5.1** released (Python 3.14 supported)
-- **[09-29-2025] 🎉 900K+ Downloads! Thanks to our amazing community!**
 - [07-27-2025] EasyGraph **v1.5** released (This version integrates the HWNN model and supports 11 representative network datasets)
 - **[06-29-2025] 🎉 800K+ Downloads!**
 - [11-22-2024] EasyGraph **v1.4.1** released (Python 3.13 supported)

{python_easygraph-1.6 → python_easygraph-1.6.1}/cpp_easygraph/cpp_easygraph.cpp

@@ -100,6 +100,9 @@ PYBIND11_MODULE(cpp_easygraph, m) {
     m.def("cpp_plain_bfs", &plain_bfs, py::arg("G"), py::arg("source"));
     m.def("cpp_kruskal_mst_edges", &kruskal_mst_edges, py::arg("G"), py::arg("minimum") = true, py::arg("weight") = "weight", py::arg("data") = true, py::arg("ignore_nan") = false);
     m.def("cpp_prim_mst_edges", &prim_mst_edges, py::arg("G"), py::arg("minimum") = true, py::arg("weight") = "weight", py::arg("data") = true, py::arg("ignore_nan") = false);
+    m.def("cpp_boruvka_mst_edges", &boruvka_mst_edges, py::arg("G"), py::arg("minimum") = true, py::arg("weight") = "weight", py::arg("data") = true, py::arg("ignore_nan") = false);
+    m.def("cpp_average_shortest_path_length", &average_shortest_path_length, py::arg("G"), py::arg("weight") = py::none(), py::arg("method") = py::none());
+    m.def("cpp_eccentricity", &eccentricity, py::arg("G"), py::arg("v") = py::none(), py::arg("sp") = py::none());
     m.def("cpp_connected_components_undirected", &connected_component_undirected, py::arg("G"));
     m.def("cpp_connected_components_directed", &connected_component_directed, py::arg("G"));
 }

python_easygraph-1.6.1/cpp_easygraph/functions/path/average_shortest_path_length.cpp

@@ -0,0 +1,148 @@
+#include "path.h"
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#include "../../classes/graph.h"
+#include "../../common/utils.h"
+#include "../../classes/linkgraph.h"
+
+#include <vector>
+#include <queue>
+#include <limits>
+#include <string>
+
+double _bfs_sum(const Graph_L& G_l, int source) {
+    int N = G_l.n;
+    std::vector<int> dis(N + 1, -1);
+    std::queue<int> q;
+
+    dis[source] = 0;
+    q.push(source);
+
+    double sum = 0.0;
+    int visited_count = 0;
+
+    const std::vector<int>& head = G_l.head;
+    const std::vector<LinkEdge>& E = G_l.edges;
+
+    while (!q.empty()) {
+        int u = q.front();
+        q.pop();
+        sum += dis[u];
+        visited_count++;
+
+        for (int p = head[u]; p != -1; p = E[p].next) {
+            int v = E[p].to;
+            if (dis[v] == -1) {
+                dis[v] = dis[u] + 1;
+                q.push(v);
+            }
+        }
+    }
+    return (visited_count == N) ? sum : -1.0;
+}
+
+double _dijkstra_sum(const Graph_L& G_l, int source) {
+    int N = G_l.n;
+    const double INF = std::numeric_limits<double>::infinity();
+    std::vector<double> dis(N + 1, INF);
+    std::priority_queue<std::pair<double, int>, 
+                        std::vector<std::pair<double, int>>, 
+                        std::greater<std::pair<double, int>>> pq;
+
+    dis[source] = 0.0;
+    pq.push({0.0, source});
+
+    double sum = 0.0;
+    int visited_count = 0;
+
+    const std::vector<int>& head = G_l.head;
+    const std::vector<LinkEdge>& E = G_l.edges;
+
+    while (!pq.empty()) {
+        auto top_node = pq.top();
+        double d = top_node.first;
+        int u = top_node.second;
+        pq.pop();
+
+        if (d > dis[u]) continue;
+        sum += d;
+        visited_count++;
+
+        for (int p = head[u]; p != -1; p = E[p].next) {
+            int v = E[p].to;
+            double w = static_cast<double>(E[p].w); 
+            if (dis[u] + w < dis[v]) {
+                dis[v] = dis[u] + w;
+                pq.push({dis[v], v});
+            }
+        }
+    }
+    return (visited_count == N) ? sum : -1.0;
+}
+
+
+py::object average_shortest_path_length(py::object G, py::object weight, py::object method) {
+    Graph& G_ = G.cast<Graph&>();
+    bool is_directed = G.attr("is_directed")().cast<bool>();
+    
+    std::string weight_key = "";
+    if (!weight.is_none()) {
+        weight_key = weight.cast<std::string>();
+    }
+
+    std::string method_str;
+    if (method.is_none()) {
+        method_str = weight.is_none() ? "single_source_bfs" : "dijkstra";
+    } else {
+        method_str = method.cast<std::string>();
+    }
+
+    if(G_.linkgraph_dirty){
+        G_.linkgraph_structure = graph_to_linkgraph(G_, is_directed, weight_key, true, false);
+        G_.linkgraph_dirty = false;
+    }
+    const Graph_L& G_l = G_.linkgraph_structure;
+
+    int N = G_l.n;
+    if (N <= 1) return py::float_(0.0);
+
+    double total_sum = 0.0;
+    bool is_connected = true;
+
+    {
+        py::gil_scoped_release release;
+
+        #pragma omp parallel for reduction(+:total_sum) schedule(dynamic)
+        for (int i = 1; i <= N; i++) {
+            if (!is_connected) continue; 
+
+            double local_sum = 0.0;
+            if (method_str == "single_source_bfs" || method_str == "unweighted") {
+                local_sum = _bfs_sum(G_l, i);
+            } else {
+                local_sum = _dijkstra_sum(G_l, i);
+            }
+
+            if (local_sum < 0) {
+                #pragma omp critical
+                is_connected = false;
+            } else {
+                total_sum += local_sum;
+            }
+        }
+    }
+
+    if (!is_connected) {  
+        if (is_directed) {
+            throw py::value_error("Graph is not strongly connected.");
+        } 
+        else {
+            throw py::value_error("Graph is not connected.");
+        }
+    }
+
+    return py::float_(total_sum / (static_cast<double>(N) * (N - 1)));
+}

python_easygraph-1.6.1/cpp_easygraph/functions/path/diameter.cpp

@@ -0,0 +1,207 @@
+#include "path.h"
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+#include "../../classes/graph.h"
+#include "../../common/utils.h"
+#include "../../classes/linkgraph.h"
+
+#include <vector>
+#include <queue>
+#include <limits>
+#include <string>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+double _bfs_eccentricity(const Graph_L& G_l, int source) {
+    int N = G_l.n;
+    std::vector<int> dis(N + 1, -1);
+    std::queue<int> q;
+
+    dis[source] = 0;
+    q.push(source);
+
+    double max_dist = 0.0;
+    int visited_count = 0;
+
+    const std::vector<int>& head = G_l.head;
+    const std::vector<LinkEdge>& E = G_l.edges;
+
+    while (!q.empty()) {
+        int u = q.front();
+        q.pop();
+        visited_count++;
+        
+        if (dis[u] > max_dist) {
+            max_dist = dis[u];
+        }
+
+        for (int p = head[u]; p != -1; p = E[p].next) {
+            int v = E[p].to;
+            if (dis[v] == -1) {
+                dis[v] = dis[u] + 1;
+                q.push(v);
+            }
+        }
+    }
+    
+    return (visited_count == N) ? max_dist : -1.0;
+}
+
+
+py::object eccentricity(py::object G, py::object v = py::none(), py::object sp = py::none()) {
+    Graph& G_ = G.cast<Graph&>();
+
+    bool is_directed = py::hasattr(G, "is_directed") ? G.attr("is_directed")().cast<bool>() : false;
+    
+    int order = py::len(G.attr("nodes"));
+
+    if (!sp.is_none()) {
+        py::dict result;
+        py::dict sp_dict = sp.cast<py::dict>();
+        
+        py::list nodes_to_check;
+        bool is_single = false;
+        
+        if (v.is_none()) {
+            nodes_to_check = py::list(G.attr("nodes"));
+        } else if (py::isinstance<py::list>(v) || py::isinstance<py::tuple>(v) || py::isinstance<py::set>(v)) {
+            nodes_to_check = py::list(v);
+        } else {
+            nodes_to_check.append(v);
+            is_single = true;
+        }
+
+        for (py::handle n : nodes_to_check) {
+            if (!sp_dict.contains(n)) {
+                throw py::type_error("Format of 'sp' is invalid.");
+            }
+            py::dict length_dict = sp_dict[n].cast<py::dict>();
+            if (py::len(length_dict) != order) {
+                std::string msg = is_directed ? 
+                    "Found infinite path length because the digraph is not strongly connected" :
+                    "Found infinite path length because the graph is not connected";
+                throw py::value_error(msg);
+            }
+            
+            double max_val = 0.0;
+            for (auto item : length_dict) {
+                double val = item.second.cast<double>();
+                if (val > max_val) max_val = val;
+            }
+            result[n] = max_val;
+        }
+        
+        if (is_single) return result[v];
+        return result;
+    }
+
+    if (G_.linkgraph_dirty) {
+        G_.linkgraph_structure = graph_to_linkgraph(G_, is_directed, "", true, false);
+        G_.linkgraph_dirty = false;
+    }
+    const Graph_L& G_l = G_.linkgraph_structure;
+
+    int N = G_l.n;
+    if (N == 0) return py::dict();
+
+    py::dict node_index;
+    std::vector<py::object> index_to_node_vec;
+
+    if (py::hasattr(G, "node_index")) {
+        node_index = G.attr("node_index").cast<py::dict>();
+    } else {
+        int idx = 0;
+        for (py::handle n : G.attr("nodes")) {
+            node_index[n] = py::cast(idx++);
+        }
+    }
+
+    if (py::hasattr(G, "index_node")) {
+        py::object idx_n = G.attr("index_node");
+        if (py::isinstance<py::list>(idx_n)) {
+            py::list l = idx_n.cast<py::list>();
+            for (auto item : l) index_to_node_vec.push_back(item.cast<py::object>());
+        } else if (py::isinstance<py::dict>(idx_n)) {
+            py::dict d = idx_n.cast<py::dict>();
+            index_to_node_vec.resize(py::len(d));
+            for (auto item : d) {
+                index_to_node_vec[item.first.cast<int>()] = item.second.cast<py::object>();
+            }
+        }
+    } else {
+        index_to_node_vec.resize(py::len(node_index));
+        for (auto item : node_index) {
+            index_to_node_vec[item.second.cast<int>()] = item.first.cast<py::object>();
+        }
+    }
+
+    std::vector<int> target_ids;
+    bool is_single_node = false;
+
+    if (v.is_none()) {
+        target_ids.resize(N);
+        for (int i = 0; i < N; ++i) target_ids[i] = i + 1;
+    } else if (py::isinstance<py::list>(v) || py::isinstance<py::tuple>(v) || py::isinstance<py::set>(v)) {
+        py::iterable v_iterable = v.cast<py::iterable>();
+        for (py::handle node : v_iterable) {
+            if (node_index.contains(node)) {
+                target_ids.push_back(node_index[node].cast<int>() + 1);
+            }
+        }
+    } else {
+        if (node_index.contains(v)) {
+            is_single_node = true;
+            target_ids.push_back(node_index[v].cast<int>() + 1);
+        } else {
+            throw py::value_error("Node not found in graph.");
+        }
+    }
+
+    int num_targets = target_ids.size();
+    if (num_targets == 0) return py::dict();
+
+    std::vector<double> ecc_values(num_targets, -1.0);
+    bool is_connected = true;
+
+    {
+        py::gil_scoped_release release;
+
+        #pragma omp parallel for schedule(dynamic)
+        for (int i = 0; i < num_targets; i++) {
+            if (!is_connected) continue;
+            int u = target_ids[i];
+            
+            double ecc_val = _bfs_eccentricity(G_l, u); 
+
+            if (ecc_val < 0) {
+                #pragma omp critical
+                is_connected = false;
+            } else {
+                ecc_values[i] = ecc_val;
+            }
+        }
+    }
+
+    if (!is_connected) {  
+        std::string msg = is_directed ? 
+            "Found infinite path length because the digraph is not strongly connected" :
+            "Found infinite path length because the graph is not connected";
+        throw py::value_error(msg);
+    }
+
+    if (is_single_node) {
+        return py::cast(ecc_values[0]);
+    } else {
+        py::dict result;
+        for (int i = 0; i < num_targets; i++) {
+            int internal_id = target_ids[i];
+            py::object original_node = index_to_node_vec[internal_id - 1]; 
+            result[original_node] = ecc_values[i];
+        }
+        return result;
+    }
+}

{python_easygraph-1.6 → python_easygraph-1.6.1}/cpp_easygraph/functions/path/mst.cpp

@@ -1,5 +1,7 @@
 #include "mst.h"
-
+#ifdef _OPENMP
+#include <omp.h>
+#endif
 #include <cmath>
 
 #include "../../classes/graph.h"
@@ -167,3 +169,146 @@ py::object prim_mst_edges(py::object G, py::object minimum, py::object weight, p
     }
     return res;
 }
+
+struct CompactEdge {
+    int u, v, id;
+    double wt;
+};
+
+struct AtomicBest {
+    std::atomic<int> edge_idx;
+    AtomicBest() : edge_idx(-1) {}
+    AtomicBest(const AtomicBest& other) : edge_idx(other.edge_idx.load()) {}
+};
+
+struct IntUnionFind {
+    std::vector<int> parent;
+    std::vector<int> rank;
+    int component_count;
+
+    IntUnionFind(int n) : parent(n), rank(n, 0), component_count(n) {
+        for (int i = 0; i < n; i++) parent[i] = i;
+    }
+
+    int find(int i) {
+        if (parent[i] == i) return i;
+        return parent[i] = find(parent[i]); 
+    }
+
+    int find_readonly(int i) const {
+        while (i != parent[i]) {
+            i = parent[i];
+        }
+        return i;
+    }
+    
+    bool unite(int i, int j) {
+        int root_i = find(i);
+        int root_j = find(j);
+        if (root_i != root_j) {
+            if (rank[root_i] < rank[root_j]) parent[root_i] = root_j;
+            else if (rank[root_i] > rank[root_j]) parent[root_j] = root_i;
+            else { parent[root_i] = root_j; rank[root_j]++; }
+            component_count--;
+            return true;
+        }
+        return false;
+    }
+};
+
+py::object boruvka_mst_edges(py::object G, py::object minimum, py::object weight, py::object data, py::object ignore_nan) {
+    Graph& G_ = G.cast<Graph&>();
+    std::string weight_key = weight_to_string(weight);
+    int sign = minimum.cast<bool>() ? 1 : -1;
+    bool return_data = data.cast<bool>();
+    bool ignore_n = ignore_nan.cast<bool>();
+
+    std::shared_ptr<COOGraph> coo = G_.gen_COO(weight_key);
+    int num_nodes = coo->nodes.size();
+    int num_edges = coo->row.size();
+
+    if (num_nodes == 0) return py::list();
+
+    std::vector<CompactEdge> active_edges;
+    active_edges.reserve(num_edges);
+    
+    const auto& W_vec = *(coo->W_map[weight_key]); 
+
+    for (int i = 0; i < num_edges; ++i) {
+        double wt = W_vec[i] * sign;
+        if (std::isnan(wt)) {
+            if (!ignore_n) {
+                PyErr_Format(PyExc_ValueError, "NaN found as an edge weight.");
+                return py::none();
+            }
+            continue;
+        }
+        active_edges.push_back({coo->row[i], coo->col[i], i, wt});
+    }
+
+    IntUnionFind uf(num_nodes);
+    std::vector<bool> in_mst(num_edges, false);
+    {
+        py::gil_scoped_release release;
+        
+        while (uf.component_count > 1) {
+            std::vector<AtomicBest> best_at(num_nodes);
+            bool changed = false;
+
+            #pragma omp parallel for
+            for (int i = 0; i < (int)active_edges.size(); ++i) {
+                int root_u = uf.find_readonly(active_edges[i].u);
+                int root_v = uf.find_readonly(active_edges[i].v);   
+
+                if (root_u != root_v) {
+                    auto update_best = [&](int root, int edge_idx) {
+                        int current = best_at[root].edge_idx.load(std::memory_order_relaxed);
+                        while (current == -1 || active_edges[edge_idx].wt < active_edges[current].wt) {
+                            if (best_at[root].edge_idx.compare_exchange_weak(current, edge_idx)) break;
+                        }
+                    };
+                    update_best(root_u, i);
+                    update_best(root_v, i);
+                }
+            }
+
+            for (int i = 0; i < num_nodes; ++i) {
+                int e_idx = best_at[i].edge_idx.load();
+                if (e_idx != -1) {
+                    const auto& e = active_edges[e_idx];
+                    if (uf.unite(e.u, e.v)) {
+                        in_mst[e.id] = true;
+                        changed = true;
+                    }
+                }
+            }
+
+            if (!changed) break;
+
+            auto new_end = std::remove_if(active_edges.begin(), active_edges.end(), [&](const CompactEdge& e) {
+                return uf.find(e.u) == uf.find(e.v);
+            });
+            active_edges.erase(new_end, active_edges.end());
+        }
+    }
+
+    py::list ret;
+    for (int i = 0; i < num_edges; ++i) {
+        if (in_mst[i]) {
+            node_t u = coo->nodes[coo->row[i]];
+            node_t v = coo->nodes[coo->col[i]];
+            
+            py::object u_obj = G_.id_to_node[py::cast(u)];
+            py::object v_obj = G_.id_to_node[py::cast(v)];
+
+            if (return_data) {
+                const auto& edge_attr = G_.adj.at(u).at(v);
+                ret.append(py::make_tuple(u_obj, v_obj, attr_to_dict(edge_attr)));
+            } else {
+                ret.append(py::make_tuple(u_obj, v_obj));
+            }
+        }
+    }
+
+    return ret;
+}

{python_easygraph-1.6 → python_easygraph-1.6.1}/cpp_easygraph/functions/path/mst.h

@@ -16,3 +16,4 @@ class UnionFind {
 
 py::object kruskal_mst_edges(py::object G, py::object minimum, py::object weight, py::object data, py::object ignore_nan);
 py::object prim_mst_edges(py::object G, py::object minimum, py::object weight, py::object data, py::object ignore_nan);
+py::object boruvka_mst_edges(py::object G, py::object minimum, py::object weight, py::object data, py::object ignore_nan);