okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/generators/tests/test_community.py

@@ -1,362 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-def test_random_partition_graph():
-    G = nx.random_partition_graph([3, 3, 3], 1, 0, seed=42)
-    C = G.graph["partition"]
-    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
-    assert len(G) == 9
-    assert len(list(G.edges())) == 9
-
-    G = nx.random_partition_graph([3, 3, 3], 0, 1)
-    C = G.graph["partition"]
-    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
-    assert len(G) == 9
-    assert len(list(G.edges())) == 27
-
-    G = nx.random_partition_graph([3, 3, 3], 1, 0, directed=True)
-    C = G.graph["partition"]
-    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
-    assert len(G) == 9
-    assert len(list(G.edges())) == 18
-
-    G = nx.random_partition_graph([3, 3, 3], 0, 1, directed=True)
-    C = G.graph["partition"]
-    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
-    assert len(G) == 9
-    assert len(list(G.edges())) == 54
-
-    G = nx.random_partition_graph([1, 2, 3, 4, 5], 0.5, 0.1)
-    C = G.graph["partition"]
-    assert C == [{0}, {1, 2}, {3, 4, 5}, {6, 7, 8, 9}, {10, 11, 12, 13, 14}]
-    assert len(G) == 15
-
-    rpg = nx.random_partition_graph
-    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 1.1, 0.1)
-    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], -0.1, 0.1)
-    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, 1.1)
-    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, -0.1)
-
-
-def test_planted_partition_graph():
-    G = nx.planted_partition_graph(4, 3, 1, 0, seed=42)
-    C = G.graph["partition"]
-    assert len(C) == 4
-    assert len(G) == 12
-    assert len(list(G.edges())) == 12
-
-    G = nx.planted_partition_graph(4, 3, 0, 1)
-    C = G.graph["partition"]
-    assert len(C) == 4
-    assert len(G) == 12
-    assert len(list(G.edges())) == 54
-
-    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42)
-    C = G.graph["partition"]
-    assert len(C) == 10
-    assert len(G) == 40
-
-    G = nx.planted_partition_graph(4, 3, 1, 0, directed=True)
-    C = G.graph["partition"]
-    assert len(C) == 4
-    assert len(G) == 12
-    assert len(list(G.edges())) == 24
-
-    G = nx.planted_partition_graph(4, 3, 0, 1, directed=True)
-    C = G.graph["partition"]
-    assert len(C) == 4
-    assert len(G) == 12
-    assert len(list(G.edges())) == 108
-
-    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42, directed=True)
-    C = G.graph["partition"]
-    assert len(C) == 10
-    assert len(G) == 40
-
-    ppg = nx.planted_partition_graph
-    pytest.raises(nx.NetworkXError, ppg, 3, 3, 1.1, 0.1)
-    pytest.raises(nx.NetworkXError, ppg, 3, 3, -0.1, 0.1)
-    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, 1.1)
-    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, -0.1)
-
-
-def test_relaxed_caveman_graph():
-    G = nx.relaxed_caveman_graph(4, 3, 0)
-    assert len(G) == 12
-    G = nx.relaxed_caveman_graph(4, 3, 1)
-    assert len(G) == 12
-    G = nx.relaxed_caveman_graph(4, 3, 0.5)
-    assert len(G) == 12
-    G = nx.relaxed_caveman_graph(4, 3, 0.5, seed=42)
-    assert len(G) == 12
-
-
-def test_connected_caveman_graph():
-    G = nx.connected_caveman_graph(4, 3)
-    assert len(G) == 12
-
-    G = nx.connected_caveman_graph(1, 5)
-    K5 = nx.complete_graph(5)
-    K5.remove_edge(3, 4)
-    assert nx.is_isomorphic(G, K5)
-
-    # need at least 2 nodes in each clique
-    pytest.raises(nx.NetworkXError, nx.connected_caveman_graph, 4, 1)
-
-
-def test_caveman_graph():
-    G = nx.caveman_graph(4, 3)
-    assert len(G) == 12
-
-    G = nx.caveman_graph(5, 1)
-    E5 = nx.empty_graph(5)
-    assert nx.is_isomorphic(G, E5)
-
-    G = nx.caveman_graph(1, 5)
-    K5 = nx.complete_graph(5)
-    assert nx.is_isomorphic(G, K5)
-
-
-def test_gaussian_random_partition_graph():
-    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01)
-    assert len(G) == 100
-    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01, directed=True)
-    assert len(G) == 100
-    G = nx.gaussian_random_partition_graph(
-        100, 10, 10, 0.3, 0.01, directed=False, seed=42
-    )
-    assert len(G) == 100
-    assert not isinstance(G, nx.DiGraph)
-    G = nx.gaussian_random_partition_graph(
-        100, 10, 10, 0.3, 0.01, directed=True, seed=42
-    )
-    assert len(G) == 100
-    assert isinstance(G, nx.DiGraph)
-    pytest.raises(
-        nx.NetworkXError, nx.gaussian_random_partition_graph, 100, 101, 10, 1, 0
-    )
-    # Test when clusters are likely less than 1
-    G = nx.gaussian_random_partition_graph(10, 0.5, 0.5, 0.5, 0.5, seed=1)
-    assert len(G) == 10
-
-
-def test_ring_of_cliques():
-    for i in range(2, 20, 3):
-        for j in range(2, 20, 3):
-            G = nx.ring_of_cliques(i, j)
-            assert G.number_of_nodes() == i * j
-            if i != 2 or j != 1:
-                expected_num_edges = i * (((j * (j - 1)) // 2) + 1)
-            else:
-                # the edge that already exists cannot be duplicated
-                expected_num_edges = i * (((j * (j - 1)) // 2) + 1) - 1
-            assert G.number_of_edges() == expected_num_edges
-    with pytest.raises(
-        nx.NetworkXError, match="A ring of cliques must have at least two cliques"
-    ):
-        nx.ring_of_cliques(1, 5)
-    with pytest.raises(
-        nx.NetworkXError, match="The cliques must have at least two nodes"
-    ):
-        nx.ring_of_cliques(3, 0)
-
-
-def test_windmill_graph():
-    for n in range(2, 20, 3):
-        for k in range(2, 20, 3):
-            G = nx.windmill_graph(n, k)
-            assert G.number_of_nodes() == (k - 1) * n + 1
-            assert G.number_of_edges() == n * k * (k - 1) / 2
-            assert G.degree(0) == G.number_of_nodes() - 1
-            for i in range(1, G.number_of_nodes()):
-                assert G.degree(i) == k - 1
-    with pytest.raises(
-        nx.NetworkXError, match="A windmill graph must have at least two cliques"
-    ):
-        nx.windmill_graph(1, 3)
-    with pytest.raises(
-        nx.NetworkXError, match="The cliques must have at least two nodes"
-    ):
-        nx.windmill_graph(3, 0)
-
-
-def test_stochastic_block_model():
-    sizes = [75, 75, 300]
-    probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
-    G = nx.stochastic_block_model(sizes, probs, seed=0)
-    C = G.graph["partition"]
-    assert len(C) == 3
-    assert len(G) == 450
-    assert G.size() == 22160
-
-    GG = nx.stochastic_block_model(sizes, probs, range(450), seed=0)
-    assert G.nodes == GG.nodes
-
-    # Test Exceptions
-    sbm = nx.stochastic_block_model
-    badnodelist = list(range(400))  # not enough nodes to match sizes
-    badprobs1 = [[0.25, 0.05, 1.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
-    badprobs2 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
-    probs_rect1 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07]]
-    probs_rect2 = [[0.25, 0.05], [0.05, -0.35], [0.02, 0.07]]
-    asymprobs = [[0.25, 0.05, 0.01], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
-    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs1)
-    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs2)
-    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect1, directed=True)
-    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect2, directed=True)
-    pytest.raises(nx.NetworkXException, sbm, sizes, asymprobs, directed=False)
-    pytest.raises(nx.NetworkXException, sbm, sizes, probs, badnodelist)
-    nodelist = [0] + list(range(449))  # repeated node name in nodelist
-    pytest.raises(nx.NetworkXException, sbm, sizes, probs, nodelist)
-
-    # Extra keyword arguments test
-    GG = nx.stochastic_block_model(sizes, probs, seed=0, selfloops=True)
-    assert G.nodes == GG.nodes
-    GG = nx.stochastic_block_model(sizes, probs, selfloops=True, directed=True)
-    assert G.nodes == GG.nodes
-    GG = nx.stochastic_block_model(sizes, probs, seed=0, sparse=False)
-    assert G.nodes == GG.nodes
-
-
-def test_generator():
-    n = 250
-    tau1 = 3
-    tau2 = 1.5
-    mu = 0.1
-    G = nx.LFR_benchmark_graph(
-        n, tau1, tau2, mu, average_degree=5, min_community=20, seed=10
-    )
-    assert len(G) == 250
-    C = {frozenset(G.nodes[v]["community"]) for v in G}
-    assert nx.community.is_partition(G.nodes(), C)
-
-
-def test_invalid_tau1():
-    with pytest.raises(nx.NetworkXError, match="tau2 must be greater than one"):
-        n = 100
-        tau1 = 2
-        tau2 = 1
-        mu = 0.1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
-
-
-def test_invalid_tau2():
-    with pytest.raises(nx.NetworkXError, match="tau1 must be greater than one"):
-        n = 100
-        tau1 = 1
-        tau2 = 2
-        mu = 0.1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
-
-
-def test_mu_too_large():
-    with pytest.raises(nx.NetworkXError, match="mu must be in the interval \\[0, 1\\]"):
-        n = 100
-        tau1 = 2
-        tau2 = 2
-        mu = 1.1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
-
-
-def test_mu_too_small():
-    with pytest.raises(nx.NetworkXError, match="mu must be in the interval \\[0, 1\\]"):
-        n = 100
-        tau1 = 2
-        tau2 = 2
-        mu = -1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
-
-
-def test_both_degrees_none():
-    with pytest.raises(
-        nx.NetworkXError,
-        match="Must assign exactly one of min_degree and average_degree",
-    ):
-        n = 100
-        tau1 = 2
-        tau2 = 2
-        mu = 1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu)
-
-
-def test_neither_degrees_none():
-    with pytest.raises(
-        nx.NetworkXError,
-        match="Must assign exactly one of min_degree and average_degree",
-    ):
-        n = 100
-        tau1 = 2
-        tau2 = 2
-        mu = 1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, average_degree=5)
-
-
-def test_max_iters_exceeded():
-    with pytest.raises(
-        nx.ExceededMaxIterations,
-        match="Could not assign communities; try increasing min_community",
-    ):
-        n = 10
-        tau1 = 2
-        tau2 = 2
-        mu = 0.1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, max_iters=10, seed=1)
-
-
-def test_max_deg_out_of_range():
-    with pytest.raises(
-        nx.NetworkXError, match="max_degree must be in the interval \\(0, n\\]"
-    ):
-        n = 10
-        tau1 = 2
-        tau2 = 2
-        mu = 0.1
-        nx.LFR_benchmark_graph(
-            n, tau1, tau2, mu, max_degree=n + 1, max_iters=10, seed=1
-        )
-
-
-def test_max_community():
-    n = 250
-    tau1 = 3
-    tau2 = 1.5
-    mu = 0.1
-    G = nx.LFR_benchmark_graph(
-        n,
-        tau1,
-        tau2,
-        mu,
-        average_degree=5,
-        max_degree=100,
-        min_community=50,
-        max_community=200,
-        seed=10,
-    )
-    assert len(G) == 250
-    C = {frozenset(G.nodes[v]["community"]) for v in G}
-    assert nx.community.is_partition(G.nodes(), C)
-
-
-def test_powerlaw_iterations_exceeded():
-    with pytest.raises(
-        nx.ExceededMaxIterations, match="Could not create power law sequence"
-    ):
-        n = 100
-        tau1 = 2
-        tau2 = 2
-        mu = 1
-        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, max_iters=0)
-
-
-def test_no_scipy_zeta():
-    zeta2 = 1.6449340668482264
-    assert abs(zeta2 - nx.generators.community._hurwitz_zeta(2, 1, 0.0001)) < 0.01
-
-
-def test_generate_min_degree_itr():
-    with pytest.raises(
-        nx.ExceededMaxIterations, match="Could not match average_degree"
-    ):
-        nx.generators.community._generate_min_degree(2, 2, 1, 0.01, 0)

package/runtime/python/okstra_vendor/networkx/generators/tests/test_degree_seq.py

@@ -1,224 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestConfigurationModel:
-    """Unit tests for the :func:`~networkx.configuration_model`
-    function.
-
-    """
-
-    def test_empty_degree_sequence(self):
-        """Tests that an empty degree sequence yields the null graph."""
-        G = nx.configuration_model([])
-        assert len(G) == 0
-
-    def test_degree_zero(self):
-        """Tests that a degree sequence of all zeros yields the empty
-        graph.
-
-        """
-        G = nx.configuration_model([0, 0, 0])
-        assert len(G) == 3
-        assert G.number_of_edges() == 0
-
-    def test_degree_sequence(self):
-        """Tests that the degree sequence of the generated graph matches
-        the input degree sequence.
-
-        """
-        deg_seq = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
-        G = nx.configuration_model(deg_seq, seed=12345678)
-        assert sorted(dict(G.degree).values()) == sorted(deg_seq)
-        assert sorted(dict(G.degree(range(len(deg_seq)))).values()) == sorted(deg_seq)
-
-    @pytest.mark.parametrize("seed", [10, 1000])
-    def test_random_seed(self, seed):
-        """Tests that each call with the same random seed generates the
-        same graph.
-
-        """
-        deg_seq = [3] * 12
-        G1 = nx.configuration_model(deg_seq, seed=seed)
-        G2 = nx.configuration_model(deg_seq, seed=seed)
-        assert nx.is_isomorphic(G1, G2)
-
-    def test_directed_disallowed(self):
-        """Tests that attempting to create a configuration model graph
-        using a directed graph yields an exception.
-
-        """
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.configuration_model([], create_using=nx.DiGraph())
-
-    def test_odd_degree_sum(self):
-        """Tests that a degree sequence whose sum is odd yields an
-        exception.
-
-        """
-        with pytest.raises(nx.NetworkXError):
-            nx.configuration_model([1, 2])
-
-
-def test_directed_configuration_raise_unequal():
-    with pytest.raises(nx.NetworkXError):
-        zin = [5, 3, 3, 3, 3, 2, 2, 2, 1, 1]
-        zout = [5, 3, 3, 3, 3, 2, 2, 2, 1, 2]
-        nx.directed_configuration_model(zin, zout)
-
-
-def test_directed_configuration_model():
-    G = nx.directed_configuration_model([], [], seed=0)
-    assert len(G) == 0
-
-
-def test_simple_directed_configuration_model():
-    G = nx.directed_configuration_model([1, 1], [1, 1], seed=0)
-    assert len(G) == 2
-
-
-def test_expected_degree_graph_empty():
-    # empty graph has empty degree sequence
-    deg_seq = []
-    G = nx.expected_degree_graph(deg_seq)
-    assert dict(G.degree()) == {}
-
-
-@pytest.mark.parametrize("seed", [10, 42, 1000])
-@pytest.mark.parametrize("deg_seq", [[3] * 12, [2, 0], [10, 2, 2, 2, 2]])
-def test_expected_degree_graph(seed, deg_seq):
-    G1 = nx.expected_degree_graph(deg_seq, seed=seed)
-    G2 = nx.expected_degree_graph(deg_seq, seed=seed)
-    assert len(G1) == len(G2) == len(deg_seq)
-    assert nx.is_isomorphic(G1, G2)
-
-
-def test_expected_degree_graph_selfloops():
-    deg_seq = [3] * 12
-    G1 = nx.expected_degree_graph(deg_seq, seed=1000, selfloops=False)
-    G2 = nx.expected_degree_graph(deg_seq, seed=1000, selfloops=False)
-    assert len(G1) == len(G2) == len(deg_seq)
-    assert nx.is_isomorphic(G1, G2)
-    assert nx.number_of_selfloops(G1) == nx.number_of_selfloops(G2) == 0
-
-
-def test_havel_hakimi_construction():
-    G = nx.havel_hakimi_graph([])
-    assert len(G) == 0
-
-    z = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
-    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
-    z = ["A", 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
-    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
-
-    z = [5, 4, 3, 3, 3, 2, 2, 2]
-    G = nx.havel_hakimi_graph(z)
-    G = nx.configuration_model(z)
-    z = [6, 5, 4, 4, 2, 1, 1, 1]
-    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z)
-
-    z = [10, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2]
-
-    G = nx.havel_hakimi_graph(z)
-
-    pytest.raises(nx.NetworkXError, nx.havel_hakimi_graph, z, create_using=nx.DiGraph())
-
-
-def test_directed_havel_hakimi():
-    # Test range of valid directed degree sequences
-    n, r = 100, 10
-    p = 1.0 / r
-    for i in range(r):
-        G1 = nx.erdos_renyi_graph(n, p * (i + 1), None, True)
-        din1 = [d for n, d in G1.in_degree()]
-        dout1 = [d for n, d in G1.out_degree()]
-        G2 = nx.directed_havel_hakimi_graph(din1, dout1)
-        din2 = [d for n, d in G2.in_degree()]
-        dout2 = [d for n, d in G2.out_degree()]
-        assert sorted(din1) == sorted(din2)
-        assert sorted(dout1) == sorted(dout2)
-
-    # Test non-graphical sequence
-    dout = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
-    din = [103, 102, 102, 102, 102, 102, 102, 102, 102, 102]
-    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
-    # Test valid sequences
-    dout = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
-    din = [2, 2, 2, 2, 2, 2, 2, 2, 0, 2]
-    G2 = nx.directed_havel_hakimi_graph(din, dout)
-    dout2 = (d for n, d in G2.out_degree())
-    din2 = (d for n, d in G2.in_degree())
-    assert sorted(dout) == sorted(dout2)
-    assert sorted(din) == sorted(din2)
-    # Test unequal sums
-    din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
-    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
-    # Test for negative values
-    din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -2]
-    pytest.raises(nx.exception.NetworkXError, nx.directed_havel_hakimi_graph, din, dout)
-
-
-@pytest.mark.parametrize(
-    "deg_seq",
-    [
-        [0],
-        [1, 1],
-        [2, 2, 2, 1, 1],
-        [3, 1, 1, 1],
-        [4, 1, 1, 1, 1],
-        [1, 1, 1, 1, 1, 2, 2, 2, 3, 4],
-    ],
-)
-def test_degree_sequence_tree(deg_seq):
-    G = nx.degree_sequence_tree(deg_seq)
-    assert sorted(dict(G.degree).values()) == sorted(deg_seq)
-    assert nx.is_tree(G)
-
-
-@pytest.mark.parametrize("graph_type", [nx.DiGraph, nx.MultiDiGraph])
-def test_degree_sequence_tree_directed(graph_type):
-    with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
-        nx.degree_sequence_tree([1, 1], create_using=graph_type())
-
-
-@pytest.mark.parametrize(
-    "deg_seq",
-    [
-        [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4],
-        [],
-        [2, 0],
-        [-1, 3],
-        [1, 16, 1, 4, 0, 0, 1, 1, 0, 1, 2, 0, 1, 0, 1, 5, 1, 2, 1, 0],
-    ],
-)
-def test_degree_sequence_tree_invalid_degree_sequence(deg_seq):
-    """Test invalid degree sequences raise an error."""
-    with pytest.raises(nx.NetworkXError, match="tree must have"):
-        nx.degree_sequence_tree(deg_seq)
-
-
-def test_random_degree_sequence_graph():
-    d = [1, 2, 2, 3]
-    G = nx.random_degree_sequence_graph(d, seed=42)
-    assert d == sorted(d for n, d in G.degree())
-
-
-def test_random_degree_sequence_graph_raise():
-    z = [1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
-    pytest.raises(nx.NetworkXUnfeasible, nx.random_degree_sequence_graph, z)
-
-
-def test_random_degree_sequence_large():
-    G1 = nx.fast_gnp_random_graph(100, 0.1, seed=42)
-    d1 = [d for n, d in G1.degree()]
-    G2 = nx.random_degree_sequence_graph(d1, seed=42)
-    d2 = [d for n, d in G2.degree()]
-    assert sorted(d1) == sorted(d2)
-
-
-def test_random_degree_sequence_iterator():
-    G1 = nx.fast_gnp_random_graph(100, 0.1, seed=42)
-    d1 = (d for n, d in G1.degree())
-    G2 = nx.random_degree_sequence_graph(d1, seed=42)
-    assert len(G2) > 0