1258064

Committed 22 Jun 2024 08:02PM UTC coverage: 69.569% (-5.5%) from 75.022%

Build # 1258064

Build Type

push

sourcehut

Committed by

tfardet

Commit Message

Version 2.8.0: support numpy >= 2

NNGT now equires matplotlib >= 3.6 and igraph >= 0.10.

**Improvements and bugfixes**

- improved colorbar for plots
- fix fallback if requested backend fails
- avoid zero width/height shapes
- improve shape falback if shapely is missing

**Compatibility**

- better matplotlib compatibility for graph-tool and igraph
- move to np.nan instead of NaN for numpy 2
- move to ``packaging`` instead of ``pkg_resources``

**Maintenance and cleanup**

- update build tests and args in setup.py and pyxbld
- remove use of old numpy random (randint/get_state)
- remove some unused imports
- ability to run compatibility tests for a subset of backends
- use venv for CI
- skip graph-tool in tests until it is fixed

Run Details

3217 of 5011 branches covered (64.2%)

Branch coverage included in aggregate %.

31 of 61 new or added lines in 17 files covered. (50.82%)

525 existing lines in 9 files now uncovered.

7576 of 10503 relevant lines covered (72.13%)

0.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.56

/nngt/lib/graph_backends.py

# -*- coding: utf-8 -*-
# SPDX-FileCopyrightText: 2015-2023 Tanguy Fardet
# SPDX-License-Identifier: GPL-3.0-or-later
# nngt/lib/graph_backends.py

""" Tools to interact with the graph libraries backends """

from importlib import reload
import logging
import sys

import nngt
from .errors import not_implemented
from .logger import _log_message
from .test_functions import mpi_barrier


logger = logging.getLogger(__name__)


# ------------------- #
# Graph library usage #
# ------------------- #

analyze_graph = {
    'adjacency': not_implemented,
    'assortativity': not_implemented,
    'betweenness': not_implemented,
    'diameter': not_implemented,
    'ebetweenness': not_implemented,
    'get_edges': not_implemented,
    'nbetweenness': not_implemented,
    'reciprocity': not_implemented,
    'scc': not_implemented,
    'wcc': not_implemented,
}


# use library function

@mpi_barrier
def use_backend(backend, reloading=True, silent=False):
    '''
    Allows the user to switch to a specific graph library as backend.

    .. warning ::
        If :class:`~nngt.Graph` objects have already been created, they will no
        longer be compatible with NNGT methods.

    Parameters
    ----------
    backend : string
        Name of a graph library among 'graph_tool', 'igraph', 'networkx', or
        'nngt'.
    reloading : bool, optional (default: True)
        Whether the graph objects should be reloaded through `reload`
        (this should always be set to True except when NNGT is first initiated!)
    silent : bool, optional (default: False)
        Whether the changes made to the configuration should be logged at the
        DEBUG (True) or INFO (False) level.
    '''
    # save old config except for graph-library data
    old_config = nngt.get_config(detailed=True)

    for k in ("graph", "backend", "library"):
        del old_config[k]

    # try to switch graph library
    success = False
    error = None

    if backend == "graph-tool":
        try:
            success = _set_graph_tool()
        except Exception as e:
            error = e
    elif backend == "igraph":
        try:
            success = _set_igraph()
        except Exception as e:
            error = e
    elif backend == "networkx":
        try:
            success = _set_networkx()
        except Exception as e:
            error = e
    elif backend == "nngt":
        try:
            success = _set_nngt()
        except Exception as e:
            error = e
    else:
        raise ValueError(f"Invalid graph library requested: '{backend}'.")

    # always reload analysis (necessary if a requested library failed partway)
    reload(sys.modules["nngt"].analysis.clustering)
    reload(sys.modules["nngt"].analysis.graph_analysis)
    reload(sys.modules["nngt"].analysis)  # must come after graph_analysis

    if reloading:
        # reload the others if necessary
        reload(sys.modules["nngt"].generation.graph_connectivity)
        reload(sys.modules["nngt"].generation)

        if nngt._config['with_plot']:
            reload(sys.modules["nngt"].plot)

        reload(sys.modules["nngt"].lib)
        reload(sys.modules["nngt"].core)  # reload first for Graph inheritance
        reload(sys.modules["nngt"].core.graph)
        reload(sys.modules["nngt"].core.spatial_graph)
        reload(sys.modules["nngt"].core.networks)

        from nngt.core.graph import Graph
        from nngt.core.spatial_graph import SpatialGraph
        from nngt.core.networks import Network, SpatialNetwork

        sys.modules["nngt"].Graph = Graph
        sys.modules["nngt"].SpatialGraph = SpatialGraph
        sys.modules["nngt"].Network = Network
        sys.modules["nngt"].SpatialNetwork = SpatialNetwork

    # make sure all other config values are unchanged
    nngt.set_config(old_config, silent=True)

    # log
    if success:
        if silent:
            _log_message(logger, "DEBUG",
                         "Successfuly switched to " + backend + ".")
        else:
            _log_message(logger, "INFO",
                         "Successfuly switched to " + backend + ".")
    else:
        if silent:
            _log_message(logger, "DEBUG",
                         "Error, could not switch to " + backend + ": "
                         "{}.".format(error))
        else:
            _log_message(logger, "WARNING",
                         "Error, could not switch to " + backend + ": "
                         "{}.".format(error))
        if error is not None:
            raise error


# ----------------- #
# Loading functions #
# ----------------- #

def _set_graph_tool():
    '''
    Set graph-tool as graph library, store relevant items in config and
    analyze graph dictionaries.
    '''
    import graph_tool as glib
    from graph_tool import Graph as GraphLib

    nngt._config["backend"] = "graph-tool"
    nngt._config["library"] = glib
    nngt._config["graph"] = GraphLib

    # store the functions
    from ..analysis import gt_functions

    _store_functions(nngt.analyze_graph, gt_functions)

    return True


def _set_igraph():
    '''
    Set igraph as graph library, store relevant items in config and
    analyze graph dictionaries.
    '''
    import igraph as glib
    from igraph import Graph as GraphLib

    nngt._config["backend"] = "igraph"
    nngt._config["library"] = glib
    nngt._config["graph"]   = GraphLib

    # store the functions
    from ..analysis import ig_functions

    _store_functions(nngt.analyze_graph, ig_functions)

    return True


def _set_networkx():
    import networkx as glib
    if glib.__version__ < '2.4':
        raise ImportError("`networkx {} is ".format(glib.__version__) +
                          "installed while version >= 2.4 is required.")

    from networkx import DiGraph as GraphLib
    nngt._config["backend"] = "networkx"
    nngt._config["library"] = glib
    nngt._config["graph"]   = GraphLib

    # store the functions
    from ..analysis import nx_functions

    _store_functions(nngt.analyze_graph, nx_functions)

    return True


def _set_nngt():
    nngt._config["backend"] = "nngt"
    nngt._config["library"] = nngt
    nngt._config["graph"]   = object

    # analysis functions
    def _notimplemented(*args, **kwargs):
        raise NotImplementedError("Install a graph library to use.")

    def get_edges(g):
        return g.edges_array

    from nngt.analysis.nngt_functions import reciprocity, adj_mat

    # store functions
    nngt.analyze_graph["assortativity"] = _notimplemented
    nngt.analyze_graph["betweenness"] = _notimplemented
    nngt.analyze_graph["diameter"] = _notimplemented
    nngt.analyze_graph["closeness"] = _notimplemented
    nngt.analyze_graph["reciprocity"] = reciprocity
    nngt.analyze_graph["connected_components"] = _notimplemented
    nngt.analyze_graph["adjacency"] = adj_mat
    nngt.analyze_graph["get_edges"] = get_edges

    return True


def _store_functions(analysis_dict, module):
    ''' Store functions from module '''
    analysis_dict["assortativity"] = module.assortativity
    analysis_dict["betweenness"] = module.betweenness
    analysis_dict["closeness"] = module.closeness
    analysis_dict["connected_components"] = module.connected_components
    analysis_dict["diameter"] = module.diameter
    analysis_dict["reciprocity"] = module.reciprocity
    analysis_dict["adjacency"] = module.adj_mat
    analysis_dict["get_edges"] = module.get_edges

1	# -- coding: utf-8 --
2	# SPDX-FileCopyrightText: 2015-2023 Tanguy Fardet
3	# SPDX-License-Identifier: GPL-3.0-or-later
4	# nngt/lib/graph_backends.py
5
6	""" Tools to interact with the graph libraries backends """
7
8	from importlib import reload	1✔
9	import logging	1✔
10	import sys	1✔
11
12	import nngt	1✔
13	from .errors import not_implemented	1✔
14	from .logger import _log_message	1✔
15	from .test_functions import mpi_barrier	1✔
16
17
18	logger = logging.getLogger(__name__)	1✔
19
20
21	# ------------------- #
22	# Graph library usage #
23	# ------------------- #
24
25	analyze_graph = {	1✔
26	'adjacency': not_implemented,
27	'assortativity': not_implemented,
28	'betweenness': not_implemented,
29	'diameter': not_implemented,
30	'ebetweenness': not_implemented,
31	'get_edges': not_implemented,
32	'nbetweenness': not_implemented,
33	'reciprocity': not_implemented,
34	'scc': not_implemented,
35	'wcc': not_implemented,
36	}
37
38
39	# use library function
40
41	@mpi_barrier	1✔
42	def use_backend(backend, reloading=True, silent=False):	1✔
43	'''
44	Allows the user to switch to a specific graph library as backend.
45
46	.. warning ::
47	If :class:`~nngt.Graph` objects have already been created, they will no
48	longer be compatible with NNGT methods.
49
50	Parameters
51	----------
52	backend : string
53	Name of a graph library among 'graph_tool', 'igraph', 'networkx', or
54	'nngt'.
55	reloading : bool, optional (default: True)
56	Whether the graph objects should be reloaded through `reload`
57	(this should always be set to True except when NNGT is first initiated!)
58	silent : bool, optional (default: False)
59	Whether the changes made to the configuration should be logged at the
60	DEBUG (True) or INFO (False) level.
61	'''
62	# save old config except for graph-library data
63	old_config = nngt.get_config(detailed=True)	1✔
64
65	for k in ("graph", "backend", "library"):	1✔
66	del old_config[k]	1✔
67
68	# try to switch graph library
69	success = False	1✔
70	error = None	1✔
71
72	if backend == "graph-tool":	1!
UNCOV 73	try:	×
UNCOV 74	success = _set_graph_tool()	×
75	except Exception as e:	×
76	error = e	×
77	elif backend == "igraph":	1✔
78	try:	1✔
79	success = _set_igraph()	1✔
80	except Exception as e:	×
81	error = e	×
82	elif backend == "networkx":	1✔
83	try:	1✔
84	success = _set_networkx()	1✔
85	except Exception as e:	×
86	error = e	×
87	elif backend == "nngt":	1✔
88	try:	1✔
89	success = _set_nngt()	1✔
90	except Exception as e:	×
91	error = e	×
92	else:
93	raise ValueError(f"Invalid graph library requested: '{backend}'.")
94
95	# always reload analysis (necessary if a requested library failed partway)
96	reload(sys.modules["nngt"].analysis.clustering)	1✔
97	reload(sys.modules["nngt"].analysis.graph_analysis)	1✔
98	reload(sys.modules["nngt"].analysis) # must come after graph_analysis	1✔
99
100	if reloading:	1✔
101	# reload the others if necessary
102	reload(sys.modules["nngt"].generation.graph_connectivity)	1✔
103	reload(sys.modules["nngt"].generation)	1✔
104
105	if nngt._config['with_plot']:	1!
106	reload(sys.modules["nngt"].plot)	1✔
107
108	reload(sys.modules["nngt"].lib)	1✔
109	reload(sys.modules["nngt"].core) # reload first for Graph inheritance	1✔
110	reload(sys.modules["nngt"].core.graph)	1✔
111	reload(sys.modules["nngt"].core.spatial_graph)	1✔
112	reload(sys.modules["nngt"].core.networks)	1✔
113
114	from nngt.core.graph import Graph	1✔
115	from nngt.core.spatial_graph import SpatialGraph	1✔
116	from nngt.core.networks import Network, SpatialNetwork	1✔
117
118	sys.modules["nngt"].Graph = Graph	1✔
119	sys.modules["nngt"].SpatialGraph = SpatialGraph	1✔
120	sys.modules["nngt"].Network = Network	1✔
121	sys.modules["nngt"].SpatialNetwork = SpatialNetwork	1✔
122
123	# make sure all other config values are unchanged
124	nngt.set_config(old_config, silent=True)	1✔
125
126	# log
127	if success:	1!
128	if silent:	1✔
129	_log_message(logger, "DEBUG",	1✔
130	"Successfuly switched to " + backend + ".")
131	else:
132	_log_message(logger, "INFO",	1✔
133	"Successfuly switched to " + backend + ".")
134	else:
135	if silent:	×
136	_log_message(logger, "DEBUG",	×
137	"Error, could not switch to " + backend + ": "
138	"{}.".format(error))
139	else:
140	_log_message(logger, "WARNING",	×
141	"Error, could not switch to " + backend + ": "
142	"{}.".format(error))
143	if error is not None:	×
144	raise error
145
146
147	# ----------------- #
148	# Loading functions #
149	# ----------------- #
150
151	def _set_graph_tool():	1✔
152	'''
153	Set graph-tool as graph library, store relevant items in config and
154	analyze graph dictionaries.
155	'''
UNCOV 156	import graph_tool as glib	×
UNCOV 157	from graph_tool import Graph as GraphLib	×
158
UNCOV 159	nngt._config["backend"] = "graph-tool"	×
UNCOV 160	nngt._config["library"] = glib	×
NEW 161	nngt._config["graph"] = GraphLib	×
162
163	# store the functions
UNCOV 164	from ..analysis import gt_functions	×
165
UNCOV 166	_store_functions(nngt.analyze_graph, gt_functions)	×
167
UNCOV 168	return True	×
169
170
171	def _set_igraph():	1✔
172	'''
173	Set igraph as graph library, store relevant items in config and
174	analyze graph dictionaries.
175	'''
176	import igraph as glib	1✔
177	from igraph import Graph as GraphLib	1✔
178
179	nngt._config["backend"] = "igraph"	1✔
180	nngt._config["library"] = glib	1✔
181	nngt._config["graph"] = GraphLib	1✔
182
183	# store the functions
184	from ..analysis import ig_functions	1✔
185
186	_store_functions(nngt.analyze_graph, ig_functions)	1✔
187
188	return True	1✔
189
190
191	def _set_networkx():	1✔
192	import networkx as glib	1✔
193	if glib.__version__ < '2.4':	1✔
194	raise ImportError("`networkx {} is ".format(glib.__version__) +
195	"installed while version >= 2.4 is required.")
196
197	from networkx import DiGraph as GraphLib	1✔
198	nngt._config["backend"] = "networkx"	1✔
199	nngt._config["library"] = glib	1✔
200	nngt._config["graph"] = GraphLib	1✔
201
202	# store the functions
203	from ..analysis import nx_functions	1✔
204
205	_store_functions(nngt.analyze_graph, nx_functions)	1✔
206
207	return True	1✔
208
209
210	def _set_nngt():	1✔
211	nngt._config["backend"] = "nngt"	1✔
212	nngt._config["library"] = nngt	1✔
213	nngt._config["graph"] = object	1✔
214
215	# analysis functions
216	def _notimplemented(args, *kwargs):	1✔
217	raise NotImplementedError("Install a graph library to use.")
218
219	def get_edges(g):	1✔
220	return g.edges_array	×
221
222	from nngt.analysis.nngt_functions import reciprocity, adj_mat	1✔
223
224	# store functions
225	nngt.analyze_graph["assortativity"] = _notimplemented	1✔
226	nngt.analyze_graph["betweenness"] = _notimplemented	1✔
227	nngt.analyze_graph["diameter"] = _notimplemented	1✔
228	nngt.analyze_graph["closeness"] = _notimplemented	1✔
229	nngt.analyze_graph["reciprocity"] = reciprocity	1✔
230	nngt.analyze_graph["connected_components"] = _notimplemented	1✔
231	nngt.analyze_graph["adjacency"] = adj_mat	1✔
232	nngt.analyze_graph["get_edges"] = get_edges	1✔
233
234	return True	1✔
235
236
237	def _store_functions(analysis_dict, module):	1✔
238	''' Store functions from module '''
239	analysis_dict["assortativity"] = module.assortativity	1✔
240	analysis_dict["betweenness"] = module.betweenness	1✔
241	analysis_dict["closeness"] = module.closeness	1✔
242	analysis_dict["connected_components"] = module.connected_components	1✔
243	analysis_dict["diameter"] = module.diameter	1✔
244	analysis_dict["reciprocity"] = module.reciprocity	1✔
245	analysis_dict["adjacency"] = module.adj_mat	1✔
246	analysis_dict["get_edges"] = module.get_edges	1✔

tfardet / NNGT / 1258064

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous