nx-parallel/nx_parallel/interface.py at 78b42c0ee3b7ae14687548aada32aae662f1bed3 · Schefflera-Arboricola/nx-parallel · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import networkx as nx

from nx_parallel.algorithms.approximation.connectivity import (
    approximate_all_pairs_node_connectivity,
)
from nx_parallel.algorithms.bipartite.redundancy import node_redundancy
from nx_parallel.algorithms.centrality.betweenness import betweenness_centrality
from nx_parallel.algorithms.cluster import square_clustering
from nx_parallel.algorithms.connectivity import connectivity
from nx_parallel.algorithms.efficiency_measures import local_efficiency
from nx_parallel.algorithms.isolate import number_of_isolates
from nx_parallel.algorithms.shortest_paths.generic import all_pairs_all_shortest_paths
from nx_parallel.algorithms.shortest_paths.unweighted import (
    all_pairs_shortest_path,
    all_pairs_shortest_path_length,
)
from nx_parallel.algorithms.shortest_paths.weighted import (
    all_pairs_bellman_ford_path,
    all_pairs_bellman_ford_path_length,
    all_pairs_dijkstra,
    all_pairs_dijkstra_path,
    all_pairs_dijkstra_path_length,
    johnson,
)
from nx_parallel.algorithms.tournament import (
    is_reachable,
    tournament_is_strongly_connected,
)
from nx_parallel.algorithms.vitality import closeness_vitality

__all__ = ["BackendInterface", "ParallelGraph"]


class ParallelGraph:
    """A wrapper class for networkx.Graph, networkx.DiGraph, networkx.MultiGraph,
    and networkx.MultiDiGraph."""

    __networkx_backend__ = "parallel"

    def __init__(self, graph_object=None):
        if graph_object is None:
            self.graph_object = nx.Graph()
        elif isinstance(
            graph_object, (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
        ):
            self.graph_object = graph_object
        else:
            self.graph_object = nx.Graph(graph_object)

    def is_multigraph(self):
        return self.graph_object.is_multigraph()

    def is_directed(self):
        return self.graph_object.is_directed()

    def __str__(self):
        return "Parallel" + str(self.graph_object)


class BackendInterface:
    """BackendInterface class for parallel algorithms."""

    # Bipartite
    node_redundancy = node_redundancy

    # Isolates
    number_of_isolates = number_of_isolates

    # Vitality
    closeness_vitality = closeness_vitality

    # Tournament
    is_reachable = is_reachable
    tournament_is_strongly_connected = tournament_is_strongly_connected

    # Centrality
    betweenness_centrality = betweenness_centrality

    # Efficiency
    local_efficiency = local_efficiency

    # Shortest Paths : generic
    all_pairs_all_shortest_paths = all_pairs_all_shortest_paths

    # Shortest Paths : weighted graphs
    all_pairs_dijkstra = all_pairs_dijkstra
    all_pairs_dijkstra_path_length = all_pairs_dijkstra_path_length
    all_pairs_dijkstra_path = all_pairs_dijkstra_path
    all_pairs_bellman_ford_path_length = all_pairs_bellman_ford_path_length
    all_pairs_bellman_ford_path = all_pairs_bellman_ford_path
    johnson = johnson

    # Clustering
    square_clustering = square_clustering

    # Shortest Paths : unweighted graphs
    all_pairs_shortest_path = all_pairs_shortest_path
    all_pairs_shortest_path_length = all_pairs_shortest_path_length

    # Approximation
    approximate_all_pairs_node_connectivity = approximate_all_pairs_node_connectivity

    # Connectivity
    all_pairs_node_connectivity = connectivity.all_pairs_node_connectivity

    # =============================

    @staticmethod
    def convert_from_nx(graph, *args, **kwargs):
        """Convert a networkx.Graph, networkx.DiGraph, networkx.MultiGraph,
        or networkx.MultiDiGraph to a ParallelGraph."""
        if isinstance(graph, ParallelGraph):
            return graph
        return ParallelGraph(graph)

    @staticmethod
    def convert_to_nx(result, *, name=None):
        """Convert a ParallelGraph to a networkx.Graph, networkx.DiGraph,
        networkx.MultiGraph, or networkx.MultiDiGraph."""
        if isinstance(result, ParallelGraph):
            return result.graph_object
        return result