okstra 0.114.0 → 0.116.0

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_swap.py

@@ -1,179 +0,0 @@
-import pytest
-
-import networkx as nx
-
-cycle = nx.cycle_graph(5, create_using=nx.DiGraph)
-tree = nx.DiGraph()
-tree.add_edges_from(nx.random_labeled_tree(10, seed=42).edges)
-path = nx.path_graph(5, create_using=nx.DiGraph)
-binomial = nx.binomial_tree(3, create_using=nx.DiGraph)
-HH = nx.directed_havel_hakimi_graph([1, 2, 1, 2, 2, 2], [3, 1, 0, 1, 2, 3])
-balanced_tree = nx.balanced_tree(2, 3, create_using=nx.DiGraph)
-
-
-@pytest.mark.parametrize("G", [path, binomial, HH, cycle, tree, balanced_tree])
-def test_directed_edge_swap(G):
-    in_degree = set(G.in_degree)
-    out_degree = set(G.out_degree)
-    edges = set(G.edges)
-    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
-    assert in_degree == set(G.in_degree)
-    assert out_degree == set(G.out_degree)
-    assert edges != set(G.edges)
-    assert 3 == sum(e not in edges for e in G.edges)
-
-
-def test_directed_edge_swap_undo_previous_swap():
-    G = nx.DiGraph(nx.path_graph(4).edges)  # only 1 swap possible
-    edges = set(G.edges)
-    nx.directed_edge_swap(G, nswap=2, max_tries=100)
-    assert edges == set(G.edges)
-
-    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
-    assert {(0, 2), (1, 3), (2, 1)} == set(G.edges)
-    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
-    assert edges == set(G.edges)
-
-
-def test_edge_cases_directed_edge_swap():
-    # Tests cases when swaps are impossible, either too few edges exist, or self loops/cycles are unavoidable
-    # TODO: Rewrite function to explicitly check for impossible swaps and raise error
-    e = (
-        "Maximum number of swap attempts \\(11\\) exceeded "
-        "before desired swaps achieved \\(\\d\\)."
-    )
-    graph = nx.DiGraph([(0, 0), (0, 1), (1, 0), (2, 3), (3, 2)])
-    with pytest.raises(nx.NetworkXAlgorithmError, match=e):
-        nx.directed_edge_swap(graph, nswap=1, max_tries=10, seed=1)
-
-
-def test_double_edge_swap():
-    graph = nx.barabasi_albert_graph(200, 1)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.double_edge_swap(graph, 40)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_double_edge_swap_seed():
-    graph = nx.barabasi_albert_graph(200, 1)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.double_edge_swap(graph, 40, seed=1)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_connected_double_edge_swap():
-    graph = nx.barabasi_albert_graph(200, 1)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.connected_double_edge_swap(graph, 40, seed=1)
-    assert nx.is_connected(graph)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_connected_double_edge_swap_low_window_threshold():
-    graph = nx.barabasi_albert_graph(200, 1)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.connected_double_edge_swap(graph, 40, _window_threshold=0, seed=1)
-    assert nx.is_connected(graph)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_connected_double_edge_swap_star():
-    # Testing ui==xi in connected_double_edge_swap
-    graph = nx.star_graph(40)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.connected_double_edge_swap(graph, 1, seed=4)
-    assert nx.is_connected(graph)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_connected_double_edge_swap_star_low_window_threshold():
-    # Testing ui==xi in connected_double_edge_swap with low window threshold
-    graph = nx.star_graph(40)
-    degrees = sorted(d for n, d in graph.degree())
-    G = nx.connected_double_edge_swap(graph, 1, _window_threshold=0, seed=4)
-    assert nx.is_connected(graph)
-    assert degrees == sorted(d for n, d in graph.degree())
-
-
-def test_directed_edge_swap_small():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.directed_edge_swap(nx.path_graph(3, create_using=nx.DiGraph))
-
-
-def test_directed_edge_swap_tries():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.directed_edge_swap(
-            nx.path_graph(3, create_using=nx.DiGraph), nswap=1, max_tries=0
-        )
-
-
-def test_directed_exception_undirected():
-    graph = nx.Graph([(0, 1), (2, 3)])
-    with pytest.raises(nx.NetworkXNotImplemented):
-        G = nx.directed_edge_swap(graph)
-
-
-def test_directed_edge_max_tries():
-    with pytest.raises(nx.NetworkXAlgorithmError):
-        G = nx.directed_edge_swap(
-            nx.complete_graph(4, nx.DiGraph()), nswap=1, max_tries=5
-        )
-
-
-def test_double_edge_swap_small():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.double_edge_swap(nx.path_graph(3))
-
-
-def test_double_edge_swap_tries():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.double_edge_swap(nx.path_graph(10), nswap=1, max_tries=0)
-
-
-def test_double_edge_directed():
-    graph = nx.DiGraph([(0, 1), (2, 3)])
-    with pytest.raises(nx.NetworkXError, match="not defined for directed graphs."):
-        G = nx.double_edge_swap(graph)
-
-
-def test_double_edge_max_tries():
-    with pytest.raises(nx.NetworkXAlgorithmError):
-        G = nx.double_edge_swap(nx.complete_graph(4), nswap=1, max_tries=5)
-
-
-def test_connected_double_edge_swap_small():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.connected_double_edge_swap(nx.path_graph(3))
-
-
-def test_connected_double_edge_swap_not_connected():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.path_graph(3)
-        nx.add_path(G, [10, 11, 12])
-        G = nx.connected_double_edge_swap(G)
-
-
-def test_degree_seq_c4():
-    G = nx.cycle_graph(4)
-    degrees = sorted(d for n, d in G.degree())
-    G = nx.double_edge_swap(G, 1, 100)
-    assert degrees == sorted(d for n, d in G.degree())
-
-
-def test_fewer_than_4_nodes():
-    G = nx.DiGraph()
-    G.add_nodes_from([0, 1, 2])
-    with pytest.raises(nx.NetworkXError, match=".*fewer than four nodes."):
-        nx.directed_edge_swap(G)
-
-
-def test_less_than_3_edges():
-    G = nx.DiGraph([(0, 1), (1, 2)])
-    G.add_nodes_from([3, 4])
-    with pytest.raises(nx.NetworkXError, match=".*fewer than 3 edges"):
-        nx.directed_edge_swap(G)
-
-    G = nx.Graph()
-    G.add_nodes_from([0, 1, 2, 3])
-    with pytest.raises(nx.NetworkXError, match=".*fewer than 2 edges"):
-        nx.double_edge_swap(G)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_threshold.py

@@ -1,270 +0,0 @@
-"""
-Threshold Graphs
-================
-"""
-
-import pytest
-
-import networkx as nx
-import networkx.algorithms.threshold as nxt
-
-cnlti = nx.convert_node_labels_to_integers
-
-
-def test_threshold_graph_invalid_creation_sequence():
-    bad_creation_sequence = [2.0, 2, 1, 0]  # floats are not allowed
-    with pytest.raises(ValueError, match="not a valid creation sequence"):
-        nxt.threshold_graph(bad_creation_sequence)
-
-
-class TestGeneratorThreshold:
-    def test_threshold_sequence_graph_test(self):
-        G = nx.star_graph(10)
-        assert nxt.is_threshold_graph(G)
-        assert nxt.is_threshold_sequence([d for n, d in G.degree()])
-
-        G = nx.complete_graph(10)
-        assert nxt.is_threshold_graph(G)
-        assert nxt.is_threshold_sequence([d for n, d in G.degree()])
-
-        deg = [3, 2, 2, 1, 1, 1]
-        assert not nxt.is_threshold_sequence(deg)
-
-        deg = [3, 2, 2, 1]
-        assert nxt.is_threshold_sequence(deg)
-
-        G = nx.generators.havel_hakimi_graph(deg)
-        assert nxt.is_threshold_graph(G)
-
-    def test_creation_sequences(self):
-        deg = [3, 2, 2, 1]
-        G = nx.generators.havel_hakimi_graph(deg)
-
-        with pytest.raises(ValueError):
-            nxt.creation_sequence(deg, with_labels=True, compact=True)
-
-        cs0 = nxt.creation_sequence(deg)
-        H0 = nxt.threshold_graph(cs0)
-        assert "".join(cs0) == "ddid"
-
-        cs1 = nxt.creation_sequence(deg, with_labels=True)
-        H1 = nxt.threshold_graph(cs1)
-        assert cs1 == [(1, "d"), (2, "d"), (3, "i"), (0, "d")]
-
-        cs2 = nxt.creation_sequence(deg, compact=True)
-        H2 = nxt.threshold_graph(cs2)
-        assert cs2 == [2, 1, 1]
-        assert "".join(nxt.uncompact(cs2)) == "ddid"
-        assert nx.could_be_isomorphic(H0, G)
-        assert nx.could_be_isomorphic(H0, H1)
-        assert nx.could_be_isomorphic(H0, H2)
-
-    def test_make_compact(self):
-        assert nxt.make_compact(["d", "d", "d", "i", "d", "d"]) == [3, 1, 2]
-        assert nxt.make_compact([3, 1, 2]) == [3, 1, 2]
-        pytest.raises(TypeError, nxt.make_compact, [3.0, 1.0, 2.0])
-
-    def test_uncompact(self):
-        assert nxt.uncompact([3, 1, 2]) == ["d", "d", "d", "i", "d", "d"]
-        assert nxt.uncompact(["d", "d", "i", "d"]) == ["d", "d", "i", "d"]
-        assert nxt.uncompact(
-            nxt.uncompact([(1, "d"), (2, "d"), (3, "i"), (0, "d")])
-        ) == nxt.uncompact([(1, "d"), (2, "d"), (3, "i"), (0, "d")])
-        pytest.raises(TypeError, nxt.uncompact, [3.0, 1.0, 2.0])
-
-    def test_creation_sequence_to_weights(self):
-        assert nxt.creation_sequence_to_weights([3, 1, 2]) == [
-            0.5,
-            0.5,
-            0.5,
-            0.25,
-            0.75,
-            0.75,
-        ]
-        pytest.raises(TypeError, nxt.creation_sequence_to_weights, [3.0, 1.0, 2.0])
-
-    def test_weights_to_creation_sequence(self):
-        deg = [3, 2, 2, 1]
-        with pytest.raises(ValueError):
-            nxt.weights_to_creation_sequence(deg, with_labels=True, compact=True)
-        assert nxt.weights_to_creation_sequence(deg, with_labels=True) == [
-            (3, "d"),
-            (1, "d"),
-            (2, "d"),
-            (0, "d"),
-        ]
-        assert nxt.weights_to_creation_sequence(deg, compact=True) == [4]
-
-    def test_find_alternating_4_cycle(self):
-        G = nx.Graph()
-        G.add_edge(1, 2)
-        assert not nxt.find_alternating_4_cycle(G)
-
-    def test_shortest_path(self):
-        deg = [3, 2, 2, 1]
-        G = nx.generators.havel_hakimi_graph(deg)
-        cs1 = nxt.creation_sequence(deg, with_labels=True)
-        for n, m in [(3, 0), (0, 3), (0, 2), (0, 1), (1, 3), (3, 1), (1, 2), (2, 3)]:
-            assert nxt.shortest_path(cs1, n, m) == nx.shortest_path(G, n, m)
-
-        spl = nxt.shortest_path_length(cs1, 3)
-        spl2 = nxt.shortest_path_length([t for v, t in cs1], 2)
-        assert spl == spl2
-
-        spld = {}
-        for j, pl in enumerate(spl):
-            n = cs1[j][0]
-            spld[n] = pl
-        assert spld == nx.single_source_shortest_path_length(G, 3)
-
-        assert nxt.shortest_path(["d", "d", "d", "i", "d", "d"], 1, 2) == [1, 2]
-        assert nxt.shortest_path([3, 1, 2], 1, 2) == [1, 2]
-        pytest.raises(TypeError, nxt.shortest_path, [3.0, 1.0, 2.0], 1, 2)
-        pytest.raises(ValueError, nxt.shortest_path, [3, 1, 2], "a", 2)
-        pytest.raises(ValueError, nxt.shortest_path, [3, 1, 2], 1, "b")
-        assert nxt.shortest_path([3, 1, 2], 1, 1) == [1]
-
-    def test_shortest_path_length(self):
-        assert nxt.shortest_path_length([3, 1, 2], 1) == [1, 0, 1, 2, 1, 1]
-        assert nxt.shortest_path_length(["d", "d", "d", "i", "d", "d"], 1) == [
-            1,
-            0,
-            1,
-            2,
-            1,
-            1,
-        ]
-        assert nxt.shortest_path_length(("d", "d", "d", "i", "d", "d"), 1) == [
-            1,
-            0,
-            1,
-            2,
-            1,
-            1,
-        ]
-        pytest.raises(TypeError, nxt.shortest_path, [3.0, 1.0, 2.0], 1)
-
-    def test_random_threshold_sequence(self):
-        assert len(nxt.random_threshold_sequence(10, 0.5)) == 10
-        assert nxt.random_threshold_sequence(10, 0.5, seed=42) == [
-            "d",
-            "i",
-            "d",
-            "d",
-            "d",
-            "i",
-            "i",
-            "i",
-            "d",
-            "d",
-        ]
-        pytest.raises(ValueError, nxt.random_threshold_sequence, 10, 1.5)
-
-    def test_right_d_threshold_sequence(self):
-        assert nxt.right_d_threshold_sequence(3, 2) == ["d", "i", "d"]
-        pytest.raises(ValueError, nxt.right_d_threshold_sequence, 2, 3)
-
-    def test_left_d_threshold_sequence(self):
-        assert nxt.left_d_threshold_sequence(3, 2) == ["d", "i", "d"]
-        pytest.raises(ValueError, nxt.left_d_threshold_sequence, 2, 3)
-
-    def test_weights_thresholds(self):
-        wseq = [3, 4, 3, 3, 5, 6, 5, 4, 5, 6]
-        cs = nxt.weights_to_creation_sequence(wseq, threshold=10)
-        wseq = nxt.creation_sequence_to_weights(cs)
-        cs2 = nxt.weights_to_creation_sequence(wseq)
-        assert cs == cs2
-
-        wseq = nxt.creation_sequence_to_weights(nxt.uncompact([3, 1, 2, 3, 3, 2, 3]))
-        assert wseq == [
-            s * 0.125 for s in [4, 4, 4, 3, 5, 5, 2, 2, 2, 6, 6, 6, 1, 1, 7, 7, 7]
-        ]
-
-        wseq = nxt.creation_sequence_to_weights([3, 1, 2, 3, 3, 2, 3])
-        assert wseq == [
-            s * 0.125 for s in [4, 4, 4, 3, 5, 5, 2, 2, 2, 6, 6, 6, 1, 1, 7, 7, 7]
-        ]
-
-        wseq = nxt.creation_sequence_to_weights(list(enumerate("ddidiiidididi")))
-        assert wseq == [s * 0.1 for s in [5, 5, 4, 6, 3, 3, 3, 7, 2, 8, 1, 9, 0]]
-
-        wseq = nxt.creation_sequence_to_weights("ddidiiidididi")
-        assert wseq == [s * 0.1 for s in [5, 5, 4, 6, 3, 3, 3, 7, 2, 8, 1, 9, 0]]
-
-        wseq = nxt.creation_sequence_to_weights("ddidiiidididid")
-        ws = [s / 12 for s in [6, 6, 5, 7, 4, 4, 4, 8, 3, 9, 2, 10, 1, 11]]
-        assert sum(abs(c - d) for c, d in zip(wseq, ws)) < 1e-14
-
-    def test_finding_routines(self):
-        G = nx.Graph({1: [2], 2: [3], 3: [4], 4: [5], 5: [6]})
-        G.add_edge(2, 4)
-        G.add_edge(2, 5)
-        G.add_edge(2, 7)
-        G.add_edge(3, 6)
-        G.add_edge(4, 6)
-
-        # Alternating 4 cycle
-        assert nxt.find_alternating_4_cycle(G) == [1, 2, 3, 6]
-
-        # Threshold graph
-        TG = nxt.find_threshold_graph(G)
-        assert nxt.is_threshold_graph(TG)
-        assert sorted(TG.nodes()) == [1, 2, 3, 4, 5, 7]
-
-        cs = nxt.creation_sequence(dict(TG.degree()), with_labels=True)
-        assert nxt.find_creation_sequence(G) == cs
-
-    def test_fast_versions_properties_threshold_graphs(self):
-        cs = "ddiiddid"
-        G = nxt.threshold_graph(cs)
-        assert nxt.density("ddiiddid") == nx.density(G)
-        assert sorted(nxt.degree_sequence(cs)) == sorted(d for n, d in G.degree())
-
-        ts = nxt.triangle_sequence(cs)
-        assert ts == list(nx.triangles(G).values())
-        assert sum(ts) // 3 == nxt.triangles(cs)
-
-        c1 = nxt.cluster_sequence(cs)
-        c2 = list(nx.clustering(G).values())
-        assert sum(abs(c - d) for c, d in zip(c1, c2)) == pytest.approx(0, abs=1e-7)
-
-        b1 = nx.betweenness_centrality(G).values()
-        b2 = nxt.betweenness_sequence(cs)
-        assert sum(abs(c - d) for c, d in zip(b1, b2)) < 1e-7
-
-        assert nxt.eigenvalues(cs) == [0, 1, 3, 3, 5, 7, 7, 8]
-
-        # Degree Correlation
-        assert abs(nxt.degree_correlation(cs) + 0.593038821954) < 1e-12
-        assert nxt.degree_correlation("diiiddi") == -0.8
-        assert nxt.degree_correlation("did") == -1.0
-        assert nxt.degree_correlation("ddd") == 1.0
-        assert nxt.eigenvalues("dddiii") == [0, 0, 0, 0, 3, 3]
-        assert nxt.eigenvalues("dddiiid") == [0, 1, 1, 1, 4, 4, 7]
-
-    def test_tg_creation_routines(self):
-        s = nxt.left_d_threshold_sequence(5, 7)
-        s = nxt.right_d_threshold_sequence(5, 7)
-
-    def test_eigenvectors(self):
-        np = pytest.importorskip("numpy")
-        eigenval = np.linalg.eigvals
-        pytest.importorskip("scipy")
-
-        cs = "ddiiddid"
-        G = nxt.threshold_graph(cs)
-        (tgeval, tgevec) = nxt.eigenvectors(cs)
-        np.testing.assert_allclose([np.dot(lv, lv) for lv in tgevec], 1.0, rtol=1e-9)
-        lapl = nx.laplacian_matrix(G)
-
-    def test_create_using(self):
-        cs = "ddiiddid"
-        G = nxt.threshold_graph(cs)
-        pytest.raises(
-            nx.exception.NetworkXError,
-            nxt.threshold_graph,
-            cs,
-            create_using=nx.DiGraph(),
-        )
-        MG = nxt.threshold_graph(cs, create_using=nx.MultiGraph())
-        assert sorted(MG.edges()) == sorted(G.edges())