okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/tests/test_all_random_functions.py

@@ -1,248 +0,0 @@
-import random
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms import approximation as approx
-from networkx.algorithms import threshold
-
-np = pytest.importorskip("numpy")
-
-progress = 0
-
-# store the random numbers after setting a global seed
-np.random.seed(42)
-np_rv = np.random.rand()
-random.seed(42)
-py_rv = random.random()
-
-
-def t(f, *args, **kwds):
-    """call one function and check if global RNG changed"""
-    global progress
-    progress += 1
-    print(progress, ",", end="")
-
-    f(*args, **kwds)
-
-    after_np_rv = np.random.rand()
-    # if np_rv != after_np_rv:
-    #    print(np_rv, after_np_rv, "don't match np!")
-    assert np_rv == after_np_rv
-    np.random.seed(42)
-
-    after_py_rv = random.random()
-    # if py_rv != after_py_rv:
-    #    print(py_rv, after_py_rv, "don't match py!")
-    assert py_rv == after_py_rv
-    random.seed(42)
-
-
-def run_all_random_functions(seed):
-    n = 20
-    m = 10
-    k = l = 2
-    s = v = 10
-    p = q = p1 = p2 = p_in = p_out = 0.4
-    alpha = radius = theta = 0.75
-    sizes = (20, 20, 10)
-    colors = [1, 2, 3]
-    G = nx.barbell_graph(12, 20)
-    H = nx.cycle_graph(3)
-    H.add_weighted_edges_from((u, v, 0.2) for u, v in H.edges)
-    deg_sequence = [3, 2, 1, 3, 2, 1, 3, 2, 1, 2, 1, 2, 1]
-    in_degree_sequence = w = sequence = aseq = bseq = deg_sequence
-
-    # print("starting...")
-    t(nx.maximal_independent_set, G, seed=seed)
-    t(nx.rich_club_coefficient, G, seed=seed, normalized=False)
-    t(nx.random_reference, G, seed=seed)
-    t(nx.lattice_reference, G, seed=seed)
-    t(nx.sigma, G, 1, 2, seed=seed)
-    t(nx.omega, G, 1, 2, seed=seed)
-    # print("out of smallworld.py")
-    t(nx.double_edge_swap, G, seed=seed)
-    # print("starting connected_double_edge_swap")
-    t(nx.connected_double_edge_swap, nx.complete_graph(9), seed=seed)
-    # print("ending connected_double_edge_swap")
-    t(nx.random_layout, G, seed=seed)
-    t(nx.fruchterman_reingold_layout, G, seed=seed)
-    t(nx.algebraic_connectivity, G, seed=seed)
-    t(nx.fiedler_vector, G, seed=seed)
-    t(nx.spectral_ordering, G, seed=seed)
-    # print('starting average_clustering')
-    t(approx.average_clustering, G, seed=seed)
-    t(approx.simulated_annealing_tsp, H, "greedy", source=1, seed=seed)
-    t(approx.threshold_accepting_tsp, H, "greedy", source=1, seed=seed)
-    t(
-        approx.traveling_salesman_problem,
-        H,
-        method=lambda G, weight: approx.simulated_annealing_tsp(
-            G, "greedy", weight, seed=seed
-        ),
-    )
-    t(
-        approx.traveling_salesman_problem,
-        H,
-        method=lambda G, weight: approx.threshold_accepting_tsp(
-            G, "greedy", weight, seed=seed
-        ),
-    )
-    t(nx.betweenness_centrality, G, seed=seed)
-    t(nx.edge_betweenness_centrality, G, seed=seed)
-    t(nx.approximate_current_flow_betweenness_centrality, G, seed=seed)
-    # print("kernighan")
-    t(nx.algorithms.community.kernighan_lin_bisection, G, seed=seed)
-    # nx.algorithms.community.asyn_lpa_communities(G, seed=seed)
-    t(nx.algorithms.tree.greedy_branching, G, seed=seed)
-    # print('done with graph argument functions')
-
-    t(nx.spectral_graph_forge, G, alpha, seed=seed)
-    t(nx.algorithms.community.asyn_fluidc, G, k, max_iter=1, seed=seed)
-    t(
-        nx.algorithms.connectivity.edge_augmentation.greedy_k_edge_augmentation,
-        G,
-        k,
-        seed=seed,
-    )
-    t(nx.algorithms.coloring.strategy_random_sequential, G, colors, seed=seed)
-
-    t(nx.configuration_model, deg_sequence, seed=seed)
-    t(
-        nx.directed_configuration_model,
-        in_degree_sequence,
-        in_degree_sequence,
-        seed=seed,
-    )
-    t(nx.expected_degree_graph, w, seed=seed)
-    t(nx.random_degree_sequence_graph, sequence, seed=seed)
-    joint_degrees = {
-        1: {4: 1},
-        2: {2: 2, 3: 2, 4: 2},
-        3: {2: 2, 4: 1},
-        4: {1: 1, 2: 2, 3: 1},
-    }
-    t(nx.joint_degree_graph, joint_degrees, seed=seed)
-    joint_degree_sequence = [
-        (1, 0),
-        (1, 0),
-        (1, 0),
-        (2, 0),
-        (1, 0),
-        (2, 1),
-        (0, 1),
-        (0, 1),
-    ]
-    t(nx.random_clustered_graph, joint_degree_sequence, seed=seed)
-    constructor = [(3, 3, 0.5), (10, 10, 0.7)]
-    t(nx.random_shell_graph, constructor, seed=seed)
-    mapping = {1: 0.4, 2: 0.3, 3: 0.3}
-    t(nx.utils.random_weighted_sample, mapping, k, seed=seed)
-    t(nx.utils.weighted_choice, mapping, seed=seed)
-    t(nx.algorithms.bipartite.configuration_model, aseq, bseq, seed=seed)
-    t(nx.algorithms.bipartite.preferential_attachment_graph, aseq, p, seed=seed)
-
-    def kernel_integral(u, w, z):
-        return z - w
-
-    t(nx.random_kernel_graph, n, kernel_integral, seed=seed)
-
-    sizes = [75, 75, 300]
-    probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
-    t(nx.stochastic_block_model, sizes, probs, seed=seed)
-    t(nx.random_partition_graph, sizes, p_in, p_out, seed=seed)
-
-    # print("starting generator functions")
-    t(threshold.random_threshold_sequence, n, p, seed=seed)
-    t(nx.tournament.random_tournament, n, seed=seed)
-    t(nx.relaxed_caveman_graph, l, k, p, seed=seed)
-    t(nx.planted_partition_graph, l, k, p_in, p_out, seed=seed)
-    t(nx.gaussian_random_partition_graph, n, s, v, p_in, p_out, seed=seed)
-    t(nx.gn_graph, n, seed=seed)
-    t(nx.gnr_graph, n, p, seed=seed)
-    t(nx.gnc_graph, n, seed=seed)
-    t(nx.scale_free_graph, n, seed=seed)
-    t(nx.directed.random_uniform_k_out_graph, n, k, seed=seed)
-    t(nx.random_k_out_graph, n, k, alpha, seed=seed)
-    N = 1000
-    t(nx.partial_duplication_graph, N, n, p, q, seed=seed)
-    t(nx.duplication_divergence_graph, n, p, seed=seed)
-    t(nx.random_geometric_graph, n, radius, seed=seed)
-    t(nx.soft_random_geometric_graph, n, radius, seed=seed)
-    t(nx.geographical_threshold_graph, n, theta, seed=seed)
-    t(nx.waxman_graph, n, seed=seed)
-    t(nx.navigable_small_world_graph, n, seed=seed)
-    t(nx.thresholded_random_geometric_graph, n, radius, theta, seed=seed)
-    t(nx.uniform_random_intersection_graph, n, m, p, seed=seed)
-    t(nx.k_random_intersection_graph, n, m, k, seed=seed)
-
-    t(nx.general_random_intersection_graph, n, 2, [0.1, 0.5], seed=seed)
-    t(nx.fast_gnp_random_graph, n, p, seed=seed)
-    t(nx.gnp_random_graph, n, p, seed=seed)
-    t(nx.dense_gnm_random_graph, n, m, seed=seed)
-    t(nx.gnm_random_graph, n, m, seed=seed)
-    t(nx.newman_watts_strogatz_graph, n, k, p, seed=seed)
-    t(nx.watts_strogatz_graph, n, k, p, seed=seed)
-    t(nx.connected_watts_strogatz_graph, n, k, p, seed=seed)
-    t(nx.random_regular_graph, 3, n, seed=seed)
-    t(nx.barabasi_albert_graph, n, m, seed=seed)
-    t(nx.extended_barabasi_albert_graph, n, m, p, q, seed=seed)
-    t(nx.powerlaw_cluster_graph, n, m, p, seed=seed)
-    t(nx.random_lobster_graph, n, p1, p2, seed=seed)
-    t(nx.random_powerlaw_tree, 5, seed=seed, tries=5000)
-    t(nx.random_powerlaw_tree_sequence, 5, seed=seed, tries=5000)
-    t(nx.random_labeled_tree, n, seed=seed)
-    t(nx.utils.powerlaw_sequence, n, seed=seed)
-    t(nx.utils.zipf_rv, 2.3, seed=seed)
-    cdist = [0.2, 0.4, 0.5, 0.7, 0.9, 1.0]
-    t(nx.utils.discrete_sequence, n, cdistribution=cdist, seed=seed)
-    t(nx.algorithms.bipartite.random_graph, n, m, p, seed=seed)
-    t(nx.algorithms.bipartite.gnmk_random_graph, n, m, k, seed=seed)
-    LFR = nx.generators.LFR_benchmark_graph
-    t(
-        LFR,
-        25,
-        3,
-        1.5,
-        0.1,
-        average_degree=3,
-        min_community=10,
-        seed=seed,
-        max_community=20,
-    )
-    t(nx.random_internet_as_graph, n, seed=seed)
-    # print("done")
-
-
-# choose to test an integer seed, or whether a single RNG can be everywhere
-# np_rng = np.random.RandomState(14)
-# seed = np_rng
-# seed = 14
-
-
-@pytest.mark.slow
-# print("NetworkX Version:", nx.__version__)
-def test_rng_interface():
-    global progress
-
-    # try different kinds of seeds
-    for seed in [14, np.random.RandomState(14)]:
-        np.random.seed(42)
-        random.seed(42)
-        run_all_random_functions(seed)
-        progress = 0
-
-        # check that both global RNGs are unaffected
-        after_np_rv = np.random.rand()
-        #        if np_rv != after_np_rv:
-        #            print(np_rv, after_np_rv, "don't match np!")
-        assert np_rv == after_np_rv
-        after_py_rv = random.random()
-        #        if py_rv != after_py_rv:
-        #            print(py_rv, after_py_rv, "don't match py!")
-        assert py_rv == after_py_rv
-
-
-#        print("\nDone testing seed:", seed)
-
-# test_rng_interface()

package/runtime/python/okstra_vendor/networkx/tests/test_convert.py

@@ -1,321 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.convert import (
-    from_dict_of_dicts,
-    from_dict_of_lists,
-    to_dict_of_dicts,
-    to_dict_of_lists,
-    to_networkx_graph,
-)
-from networkx.generators.classic import barbell_graph, cycle_graph
-from networkx.utils import edges_equal, graphs_equal, nodes_equal
-
-
-class TestConvert:
-    def edgelists_equal(self, e1, e2):
-        return sorted(sorted(e) for e in e1) == sorted(sorted(e) for e in e2)
-
-    def test_simple_graphs(self):
-        for dest, source in [
-            (to_dict_of_dicts, from_dict_of_dicts),
-            (to_dict_of_lists, from_dict_of_lists),
-        ]:
-            G = barbell_graph(10, 3)
-            G.graph = {}
-            dod = dest(G)
-
-            # Dict of [dicts, lists]
-            GG = source(dod)
-            assert graphs_equal(G, GG)
-            GW = to_networkx_graph(dod)
-            assert graphs_equal(G, GW)
-            GI = nx.Graph(dod)
-            assert graphs_equal(G, GI)
-
-            # With nodelist keyword
-            P4 = nx.path_graph(4)
-            P3 = nx.path_graph(3)
-            P4.graph = {}
-            P3.graph = {}
-            dod = dest(P4, nodelist=[0, 1, 2])
-            Gdod = nx.Graph(dod)
-            assert graphs_equal(Gdod, P3)
-
-    def test_exceptions(self):
-        # NX graph
-        class G:
-            adj = None
-
-        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
-
-        # pygraphviz  agraph
-        class G:
-            is_strict = None
-
-        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
-
-        # Dict of [dicts, lists]
-        G = {"a": 0}
-        pytest.raises(TypeError, to_networkx_graph, G)
-
-        # list or generator of edges
-        class G:
-            next = None
-
-        pytest.raises(nx.NetworkXError, to_networkx_graph, G)
-
-        # no match
-        pytest.raises(nx.NetworkXError, to_networkx_graph, "a")
-
-    def test_digraphs(self):
-        for dest, source in [
-            (to_dict_of_dicts, from_dict_of_dicts),
-            (to_dict_of_lists, from_dict_of_lists),
-        ]:
-            G = cycle_graph(10)
-
-            # Dict of [dicts, lists]
-            dod = dest(G)
-            GG = source(dod)
-            assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
-            assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
-            GW = to_networkx_graph(dod)
-            assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
-            assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
-            GI = nx.Graph(dod)
-            assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
-            assert edges_equal(sorted(G.edges()), sorted(GI.edges()))
-
-            G = cycle_graph(10, create_using=nx.DiGraph)
-            dod = dest(G)
-            GG = source(dod, create_using=nx.DiGraph)
-            assert sorted(G.nodes()) == sorted(GG.nodes())
-            assert sorted(G.edges()) == sorted(GG.edges())
-            GW = to_networkx_graph(dod, create_using=nx.DiGraph)
-            assert sorted(G.nodes()) == sorted(GW.nodes())
-            assert sorted(G.edges()) == sorted(GW.edges())
-            GI = nx.DiGraph(dod)
-            assert sorted(G.nodes()) == sorted(GI.nodes())
-            assert sorted(G.edges()) == sorted(GI.edges())
-
-    def test_graph(self):
-        g = nx.cycle_graph(10)
-        G = nx.Graph()
-        G.add_nodes_from(g)
-        G.add_weighted_edges_from((u, v, u) for u, v in g.edges())
-
-        # Dict of dicts
-        dod = to_dict_of_dicts(G)
-        GG = from_dict_of_dicts(dod, create_using=nx.Graph)
-        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
-        GW = to_networkx_graph(dod, create_using=nx.Graph)
-        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
-        GI = nx.Graph(dod)
-        assert sorted(G.nodes()) == sorted(GI.nodes())
-        assert sorted(G.edges()) == sorted(GI.edges())
-
-        # Dict of lists
-        dol = to_dict_of_lists(G)
-        GG = from_dict_of_lists(dol, create_using=nx.Graph)
-        # dict of lists throws away edge data so set it to none
-        enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)]
-        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
-        assert edges_equal(enone, sorted(GG.edges(data=True)))
-        GW = to_networkx_graph(dol, create_using=nx.Graph)
-        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
-        assert edges_equal(enone, sorted(GW.edges(data=True)))
-        GI = nx.Graph(dol)
-        assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
-        assert edges_equal(enone, sorted(GI.edges(data=True)))
-
-    def test_with_multiedges_self_loops(self):
-        G = cycle_graph(10)
-        XG = nx.Graph()
-        XG.add_nodes_from(G)
-        XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
-        XGM = nx.MultiGraph()
-        XGM.add_nodes_from(G)
-        XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
-        XGM.add_edge(0, 1, weight=2)  # multiedge
-        XGS = nx.Graph()
-        XGS.add_nodes_from(G)
-        XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
-        XGS.add_edge(0, 0, weight=100)  # self loop
-
-        # Dict of dicts
-        # with self loops, OK
-        dod = to_dict_of_dicts(XGS)
-        GG = from_dict_of_dicts(dod, create_using=nx.Graph)
-        assert nodes_equal(XGS.nodes(), GG.nodes())
-        assert edges_equal(XGS.edges(), GG.edges())
-        GW = to_networkx_graph(dod, create_using=nx.Graph)
-        assert nodes_equal(XGS.nodes(), GW.nodes())
-        assert edges_equal(XGS.edges(), GW.edges())
-        GI = nx.Graph(dod)
-        assert nodes_equal(XGS.nodes(), GI.nodes())
-        assert edges_equal(XGS.edges(), GI.edges())
-
-        # Dict of lists
-        # with self loops, OK
-        dol = to_dict_of_lists(XGS)
-        GG = from_dict_of_lists(dol, create_using=nx.Graph)
-        # dict of lists throws away edge data so set it to none
-        enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
-        assert nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
-        assert edges_equal(enone, sorted(GG.edges(data=True)))
-        GW = to_networkx_graph(dol, create_using=nx.Graph)
-        assert nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
-        assert edges_equal(enone, sorted(GW.edges(data=True)))
-        GI = nx.Graph(dol)
-        assert nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
-        assert edges_equal(enone, sorted(GI.edges(data=True)))
-
-        # Dict of dicts
-        # with multiedges, OK
-        dod = to_dict_of_dicts(XGM)
-        GG = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=True)
-        assert nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
-        assert edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
-        GW = to_networkx_graph(dod, create_using=nx.MultiGraph, multigraph_input=True)
-        assert nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
-        assert edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
-        GI = nx.MultiGraph(dod)
-        assert nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
-        assert sorted(XGM.edges()) == sorted(GI.edges())
-        GE = from_dict_of_dicts(dod, create_using=nx.MultiGraph, multigraph_input=False)
-        assert nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
-        assert sorted(XGM.edges()) != sorted(GE.edges())
-        GI = nx.MultiGraph(XGM)
-        assert nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
-        assert edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
-        GM = nx.MultiGraph(G)
-        assert nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
-        assert edges_equal(sorted(GM.edges()), sorted(G.edges()))
-
-        # Dict of lists
-        # with multiedges, OK, but better write as DiGraph else you'll
-        # get double edges
-        dol = to_dict_of_lists(G)
-        GG = from_dict_of_lists(dol, create_using=nx.MultiGraph)
-        assert nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(GG.edges()))
-        GW = to_networkx_graph(dol, create_using=nx.MultiGraph)
-        assert nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(GW.edges()))
-        GI = nx.MultiGraph(dol)
-        assert nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(GI.edges()))
-
-    def test_edgelists(self):
-        P = nx.path_graph(4)
-        e = [(0, 1), (1, 2), (2, 3)]
-        G = nx.Graph(e)
-        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
-        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
-
-        e = [(0, 1, {}), (1, 2, {}), (2, 3, {})]
-        G = nx.Graph(e)
-        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
-        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
-
-        e = ((n, n + 1) for n in range(3))
-        G = nx.Graph(e)
-        assert nodes_equal(sorted(G.nodes()), sorted(P.nodes()))
-        assert edges_equal(sorted(G.edges()), sorted(P.edges()))
-        assert edges_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
-
-    def test_directed_to_undirected(self):
-        edges1 = [(0, 1), (1, 2), (2, 0)]
-        edges2 = [(0, 1), (1, 2), (0, 2)]
-        assert self.edgelists_equal(nx.Graph(nx.DiGraph(edges1)).edges(), edges1)
-        assert self.edgelists_equal(nx.Graph(nx.DiGraph(edges2)).edges(), edges1)
-        assert self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges1)).edges(), edges1)
-        assert self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges2)).edges(), edges1)
-
-        assert self.edgelists_equal(
-            nx.MultiGraph(nx.MultiDiGraph(edges1)).edges(), edges1
-        )
-        assert self.edgelists_equal(
-            nx.MultiGraph(nx.MultiDiGraph(edges2)).edges(), edges1
-        )
-
-        assert self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges1)).edges(), edges1)
-        assert self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges2)).edges(), edges1)
-
-    def test_attribute_dict_integrity(self):
-        # we must not replace dict-like graph data structures with dicts
-        G = nx.Graph()
-        G.add_nodes_from("abc")
-        H = to_networkx_graph(G, create_using=nx.Graph)
-        assert list(H.nodes) == list(G.nodes)
-        H = nx.DiGraph(G)
-        assert list(H.nodes) == list(G.nodes)
-
-    def test_to_edgelist(self):
-        G = nx.Graph([(1, 1)])
-        elist = nx.to_edgelist(G, nodelist=list(G))
-        assert edges_equal(G.edges(data=True), elist)
-
-    def test_custom_node_attr_dict_safekeeping(self):
-        class custom_dict(dict):
-            pass
-
-        class Custom(nx.Graph):
-            node_attr_dict_factory = custom_dict
-
-        g = nx.Graph()
-        g.add_node(1, weight=1)
-
-        h = Custom(g)
-        assert isinstance(g._node[1], dict)
-        assert isinstance(h._node[1], custom_dict)
-
-        # this raise exception
-        # h._node.update((n, dd.copy()) for n, dd in g.nodes.items())
-        # assert isinstance(h._node[1], custom_dict)
-
-
-@pytest.mark.parametrize(
-    "edgelist",
-    (
-        # Graph with no edge data
-        [(0, 1), (1, 2)],
-        # Graph with edge data
-        [(0, 1, {"weight": 1.0}), (1, 2, {"weight": 2.0})],
-    ),
-)
-def test_to_dict_of_dicts_with_edgedata_param(edgelist):
-    G = nx.Graph()
-    G.add_edges_from(edgelist)
-    # Innermost dict value == edge_data when edge_data != None.
-    # In the case when G has edge data, it is overwritten
-    expected = {0: {1: 10}, 1: {0: 10, 2: 10}, 2: {1: 10}}
-    assert nx.to_dict_of_dicts(G, edge_data=10) == expected
-
-
-def test_to_dict_of_dicts_with_edgedata_and_nodelist():
-    G = nx.path_graph(5)
-    nodelist = [2, 3, 4]
-    expected = {2: {3: 10}, 3: {2: 10, 4: 10}, 4: {3: 10}}
-    assert nx.to_dict_of_dicts(G, nodelist=nodelist, edge_data=10) == expected
-
-
-def test_to_dict_of_dicts_with_edgedata_multigraph():
-    """Multi edge data overwritten when edge_data != None"""
-    G = nx.MultiGraph()
-    G.add_edge(0, 1, key="a")
-    G.add_edge(0, 1, key="b")
-    # Multi edge data lost when edge_data is not None
-    expected = {0: {1: 10}, 1: {0: 10}}
-    assert nx.to_dict_of_dicts(G, edge_data=10) == expected
-
-
-def test_to_networkx_graph_non_edgelist():
-    invalid_edgelist = [1, 2, 3]
-    with pytest.raises(nx.NetworkXError, match="Input is not a valid edge list"):
-        nx.to_networkx_graph(invalid_edgelist)