okstra 0.114.0 → 0.115.0

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

@@ -1,189 +0,0 @@
-"""Generators - Directed Graphs
-----------------------------
-"""
-
-import pytest
-
-import networkx as nx
-from networkx.classes import Graph, MultiDiGraph
-from networkx.generators.directed import (
-    _random_k_out_graph_numpy,
-    _random_k_out_graph_python,
-    gn_graph,
-    gnc_graph,
-    gnr_graph,
-    random_k_out_graph,
-    random_uniform_k_out_graph,
-    scale_free_graph,
-)
-
-try:
-    import numpy as np
-
-    has_numpy = True
-except ImportError:
-    has_numpy = False
-
-
-class TestGeneratorsDirected:
-    def test_smoke_test_random_graphs(self):
-        gn_graph(100)
-        gnr_graph(100, 0.5)
-        gnc_graph(100)
-        scale_free_graph(100)
-
-        gn_graph(100, seed=42)
-        gnr_graph(100, 0.5, seed=42)
-        gnc_graph(100, seed=42)
-        scale_free_graph(100, seed=42)
-
-    def test_create_using_keyword_arguments(self):
-        pytest.raises(nx.NetworkXError, gn_graph, 100, create_using=Graph())
-        pytest.raises(nx.NetworkXError, gnr_graph, 100, 0.5, create_using=Graph())
-        pytest.raises(nx.NetworkXError, gnc_graph, 100, create_using=Graph())
-        G = gn_graph(100, seed=1)
-        MG = gn_graph(100, create_using=MultiDiGraph(), seed=1)
-        assert sorted(G.edges()) == sorted(MG.edges())
-        G = gnr_graph(100, 0.5, seed=1)
-        MG = gnr_graph(100, 0.5, create_using=MultiDiGraph(), seed=1)
-        assert sorted(G.edges()) == sorted(MG.edges())
-        G = gnc_graph(100, seed=1)
-        MG = gnc_graph(100, create_using=MultiDiGraph(), seed=1)
-        assert sorted(G.edges()) == sorted(MG.edges())
-
-        G = scale_free_graph(
-            100,
-            alpha=0.3,
-            beta=0.4,
-            gamma=0.3,
-            delta_in=0.3,
-            delta_out=0.1,
-            initial_graph=nx.cycle_graph(4, create_using=MultiDiGraph),
-            seed=1,
-        )
-        pytest.raises(ValueError, scale_free_graph, 100, 0.5, 0.4, 0.3)
-        pytest.raises(ValueError, scale_free_graph, 100, alpha=-0.3)
-        pytest.raises(ValueError, scale_free_graph, 100, beta=-0.3)
-        pytest.raises(ValueError, scale_free_graph, 100, gamma=-0.3)
-
-    def test_parameters(self):
-        G = nx.DiGraph()
-        G.add_node(0)
-
-        def kernel(x):
-            return x
-
-        assert nx.is_isomorphic(gn_graph(1), G)
-        assert nx.is_isomorphic(gn_graph(1, kernel=kernel), G)
-        assert nx.is_isomorphic(gnc_graph(1), G)
-        assert nx.is_isomorphic(gnr_graph(1, 0.5), G)
-
-
-def test_scale_free_graph_negative_delta():
-    with pytest.raises(ValueError, match="delta_in must be >= 0."):
-        scale_free_graph(10, delta_in=-1)
-    with pytest.raises(ValueError, match="delta_out must be >= 0."):
-        scale_free_graph(10, delta_out=-1)
-
-
-def test_non_numeric_ordering():
-    G = MultiDiGraph([("a", "b"), ("b", "c"), ("c", "a")])
-    s = scale_free_graph(3, initial_graph=G)
-    assert len(s) == 3
-    assert len(s.edges) == 3
-
-
-@pytest.mark.parametrize("ig", (nx.Graph(), nx.DiGraph([(0, 1)])))
-def test_scale_free_graph_initial_graph_kwarg(ig):
-    with pytest.raises(nx.NetworkXError):
-        scale_free_graph(100, initial_graph=ig)
-
-
-class TestRandomKOutGraph:
-    """Unit tests for the
-    :func:`~networkx.generators.directed.random_k_out_graph` function.
-
-    """
-
-    @pytest.fixture(
-        params=[
-            pytest.param(
-                _random_k_out_graph_numpy,
-                marks=pytest.mark.skipif(not has_numpy, reason="numpy not installed"),
-            ),
-            _random_k_out_graph_python,
-        ]
-    )
-    def f(self, request):
-        yield request.param
-
-    @pytest.fixture(params=[(10, 3, 1), (20, 2, 4), (5, 1, 10)])
-    def nkalpha(self, request):
-        yield request.param
-
-    def test_regularity(self, f, nkalpha):
-        """Test that the generated graph is `k`-out-regular."""
-        n, k, alpha = nkalpha
-        G = f(n, k, alpha, seed=42)
-        assert all(d == k for _, d in G.out_degree)
-
-    def test_no_self_loops(self, f, nkalpha):
-        """Test for forbidding self-loops."""
-        n, k, alpha = nkalpha
-        G = f(n, k, alpha, self_loops=False, seed=42)
-        assert nx.number_of_selfloops(G) == 0
-
-    def test_random_k_out_graph(self, nkalpha):
-        """Test that the interface function `random_k_out_graph` works correctly."""
-        n, k, alpha = nkalpha
-        G = random_k_out_graph(n, k, alpha, seed=42)
-        assert len(G) == n
-        assert all(d == k for _, d in G.out_degree)
-
-    def test_negative_alpha(self):
-        with pytest.raises(ValueError, match="alpha must be positive"):
-            random_k_out_graph(10, 3, -1)
-
-
-class TestUniformRandomKOutGraph:
-    """Unit tests for the
-    :func:`~networkx.generators.directed.random_uniform_k_out_graph`
-    function.
-
-    """
-
-    def test_regularity(self):
-        """Tests that the generated graph is `k`-out-regular."""
-        n = 10
-        k = 3
-        G = random_uniform_k_out_graph(n, k)
-        assert all(d == k for v, d in G.out_degree())
-        G = random_uniform_k_out_graph(n, k, seed=42)
-        assert all(d == k for v, d in G.out_degree())
-
-    def test_no_self_loops(self):
-        """Tests for forbidding self-loops."""
-        n = 10
-        k = 3
-        G = random_uniform_k_out_graph(n, k, self_loops=False)
-        assert nx.number_of_selfloops(G) == 0
-        assert all(d == k for v, d in G.out_degree())
-
-    def test_with_replacement(self):
-        n = 10
-        k = 3
-        G = random_uniform_k_out_graph(n, k, with_replacement=True)
-        assert G.is_multigraph()
-        assert all(d == k for v, d in G.out_degree())
-        n = 10
-        k = 9
-        G = random_uniform_k_out_graph(n, k, with_replacement=False, self_loops=False)
-        assert nx.number_of_selfloops(G) == 0
-        assert all(d == k for v, d in G.out_degree())
-
-    def test_without_replacement(self):
-        n = 10
-        k = 3
-        G = random_uniform_k_out_graph(n, k, with_replacement=False)
-        assert not G.is_multigraph()
-        assert all(d == k for v, d in G.out_degree())

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

@@ -1,103 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.duplication` module."""
-
-import pytest
-
-import networkx as nx
-
-
-class TestDuplicationDivergenceGraph:
-    """Unit tests for the
-    :func:`networkx.generators.duplication.duplication_divergence_graph`
-    function.
-
-    """
-
-    def test_final_size(self):
-        G = nx.duplication_divergence_graph(3, p=1)
-        assert len(G) == 3
-        G = nx.duplication_divergence_graph(3, p=1, seed=42)
-        assert len(G) == 3
-
-    def test_probability_too_large(self):
-        with pytest.raises(nx.NetworkXError):
-            nx.duplication_divergence_graph(3, p=2)
-
-    def test_probability_too_small(self):
-        with pytest.raises(nx.NetworkXError):
-            nx.duplication_divergence_graph(3, p=-1)
-
-    def test_non_extreme_probability_value(self):
-        G = nx.duplication_divergence_graph(6, p=0.3, seed=42)
-        assert len(G) == 6
-        assert list(G.degree()) == [(0, 2), (1, 3), (2, 2), (3, 3), (4, 1), (5, 1)]
-
-    def test_minimum_desired_nodes(self):
-        with pytest.raises(
-            nx.NetworkXError, match=".*n must be greater than or equal to 2"
-        ):
-            nx.duplication_divergence_graph(1, p=1)
-
-    def test_create_using(self):
-        class DummyGraph(nx.Graph):
-            pass
-
-        class DummyDiGraph(nx.DiGraph):
-            pass
-
-        G = nx.duplication_divergence_graph(6, 0.3, seed=42, create_using=DummyGraph)
-        assert isinstance(G, DummyGraph)
-        with pytest.raises(nx.NetworkXError, match="create_using must not be directed"):
-            nx.duplication_divergence_graph(6, 0.3, seed=42, create_using=DummyDiGraph)
-
-
-class TestPartialDuplicationGraph:
-    """Unit tests for the
-    :func:`networkx.generators.duplication.partial_duplication_graph`
-    function.
-
-    """
-
-    def test_final_size(self):
-        N = 10
-        n = 5
-        p = 0.5
-        q = 0.5
-        G = nx.partial_duplication_graph(N, n, p, q)
-        assert len(G) == N
-        G = nx.partial_duplication_graph(N, n, p, q, seed=42)
-        assert len(G) == N
-
-    def test_initial_clique_size(self):
-        N = 10
-        n = 10
-        p = 0.5
-        q = 0.5
-        G = nx.partial_duplication_graph(N, n, p, q)
-        assert len(G) == n
-
-    def test_invalid_initial_size(self):
-        with pytest.raises(nx.NetworkXError):
-            N = 5
-            n = 10
-            p = 0.5
-            q = 0.5
-            G = nx.partial_duplication_graph(N, n, p, q)
-
-    def test_invalid_probabilities(self):
-        N = 1
-        n = 1
-        for p, q in [(0.5, 2), (0.5, -1), (2, 0.5), (-1, 0.5)]:
-            args = (N, n, p, q)
-            pytest.raises(nx.NetworkXError, nx.partial_duplication_graph, *args)
-
-    def test_create_using(self):
-        class DummyGraph(nx.Graph):
-            pass
-
-        class DummyDiGraph(nx.DiGraph):
-            pass
-
-        G = nx.partial_duplication_graph(10, 5, 0.5, 0.5, create_using=DummyGraph)
-        assert isinstance(G, DummyGraph)
-        with pytest.raises(nx.NetworkXError, match="create_using must not be directed"):
-            nx.partial_duplication_graph(10, 5, 0.5, 0.5, create_using=DummyDiGraph)

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

@@ -1,39 +0,0 @@
-"""
-ego graph
----------
-"""
-
-import networkx as nx
-from networkx.utils import edges_equal, nodes_equal
-
-
-class TestGeneratorEgo:
-    def test_ego(self):
-        G = nx.star_graph(3)
-        H = nx.ego_graph(G, 0)
-        assert nx.is_isomorphic(G, H)
-        G.add_edge(1, 11)
-        G.add_edge(2, 22)
-        G.add_edge(3, 33)
-        H = nx.ego_graph(G, 0)
-        assert nx.is_isomorphic(nx.star_graph(3), H)
-        G = nx.path_graph(3)
-        H = nx.ego_graph(G, 0)
-        assert edges_equal(H.edges(), [(0, 1)])
-        H = nx.ego_graph(G, 0, undirected=True)
-        assert edges_equal(H.edges(), [(0, 1)])
-        H = nx.ego_graph(G, 0, center=False)
-        assert edges_equal(H.edges(), [])
-
-    def test_ego_distance(self):
-        G = nx.Graph()
-        G.add_edge(0, 1, weight=2, distance=1)
-        G.add_edge(1, 2, weight=2, distance=2)
-        G.add_edge(2, 3, weight=2, distance=1)
-        assert nodes_equal(nx.ego_graph(G, 0, radius=3).nodes(), [0, 1, 2, 3])
-        eg = nx.ego_graph(G, 0, radius=3, distance="weight")
-        assert nodes_equal(eg.nodes(), [0, 1])
-        eg = nx.ego_graph(G, 0, radius=3, distance="weight", undirected=True)
-        assert nodes_equal(eg.nodes(), [0, 1])
-        eg = nx.ego_graph(G, 0, radius=3, distance="distance")
-        assert nodes_equal(eg.nodes(), [0, 1, 2])

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

@@ -1,182 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.expanders` module."""
-
-import pytest
-
-import networkx as nx
-
-
-@pytest.mark.parametrize("n", (2, 3, 5, 6, 10))
-def test_margulis_gabber_galil_graph_properties(n):
-    g = nx.margulis_gabber_galil_graph(n)
-    assert g.number_of_nodes() == n * n
-    for node in g:
-        assert g.degree(node) == 8
-        assert len(node) == 2
-        for i in node:
-            assert int(i) == i
-            assert 0 <= i < n
-
-
-@pytest.mark.parametrize("n", (2, 3, 5, 6, 10))
-def test_margulis_gabber_galil_graph_eigvals(n):
-    np = pytest.importorskip("numpy")
-    sp = pytest.importorskip("scipy")
-
-    g = nx.margulis_gabber_galil_graph(n)
-    # Eigenvalues are already sorted using the scipy eigvalsh,
-    # but the implementation in numpy does not guarantee order.
-    w = sorted(sp.linalg.eigvalsh(nx.adjacency_matrix(g).toarray()))
-    assert w[-2] < 5 * np.sqrt(2)
-
-
-@pytest.mark.parametrize("p", (3, 5, 7, 11))  # Primes
-def test_chordal_cycle_graph(p):
-    """Test for the :func:`networkx.chordal_cycle_graph` function."""
-    G = nx.chordal_cycle_graph(p)
-    assert len(G) == p
-    # TODO The second largest eigenvalue should be smaller than a constant,
-    # independent of the number of nodes in the graph:
-    #
-    #     eigs = sorted(sp.linalg.eigvalsh(nx.adjacency_matrix(G).toarray()))
-    #     assert_less(eigs[-2], ...)
-    #
-
-
-@pytest.mark.parametrize("p", (3, 5, 7, 11, 13))  # Primes
-def test_paley_graph(p):
-    """Test for the :func:`networkx.paley_graph` function."""
-    G = nx.paley_graph(p)
-    # G has p nodes
-    assert len(G) == p
-    # G is (p-1)/2-regular
-    in_degrees = {G.in_degree(node) for node in G.nodes}
-    out_degrees = {G.out_degree(node) for node in G.nodes}
-    assert len(in_degrees) == 1 and in_degrees.pop() == (p - 1) // 2
-    assert len(out_degrees) == 1 and out_degrees.pop() == (p - 1) // 2
-
-    # If p = 1 mod 4, -1 is a square mod 4 and therefore the
-    # edge in the Paley graph are symmetric.
-    if p % 4 == 1:
-        for u, v in G.edges:
-            assert (v, u) in G.edges
-
-
-@pytest.mark.parametrize("d, n", [(2, 7), (4, 10), (4, 16)])
-def test_maybe_regular_expander_graph(d, n):
-    pytest.importorskip("numpy")
-    G = nx.maybe_regular_expander_graph(n, d, seed=1729)
-
-    assert len(G) == n, "Should have n nodes"
-    assert len(G.edges) == n * d / 2, "Should have n*d/2 edges"
-    assert nx.is_k_regular(G, d), "Should be d-regular"
-
-
-def test_maybe_regular_expander_graph_max_tries():
-    pytest.importorskip("numpy")
-    d, n = 4, 10
-    msg = "Too many iterations in maybe_regular_expander_graph"
-    with pytest.raises(nx.NetworkXError, match=msg):
-        nx.maybe_regular_expander_graph(n, d, max_tries=100, seed=6818)  # See gh-8048
-
-    nx.maybe_regular_expander_graph(n, d, max_tries=130, seed=6818)
-
-
-def test_maybe_regular_expander_deprecated():
-    pytest.importorskip("numpy")
-    d, n = 2, 7
-    with pytest.deprecated_call():
-        G = nx.maybe_regular_expander(n, d, seed=1729)
-
-    assert len(G) == n, "Should have n nodes"
-    assert len(G.edges) == n * d / 2, "Should have n*d/2 edges"
-    assert nx.is_k_regular(G, d), "Should be d-regular"
-
-
-@pytest.mark.parametrize("n", (3, 5, 6, 10))
-def test_is_regular_expander(n):
-    pytest.importorskip("numpy")
-    pytest.importorskip("scipy")
-    G = nx.complete_graph(n)
-
-    assert nx.is_regular_expander(G), "Should be a regular expander"
-
-
-@pytest.mark.parametrize("d, n", [(2, 7), (4, 10), (4, 16), (4, 2000)])
-def test_random_regular_expander(d, n):
-    pytest.importorskip("numpy")
-    pytest.importorskip("scipy")
-    G = nx.random_regular_expander_graph(n, d, seed=1729)
-
-    assert len(G) == n, "Should have n nodes"
-    assert len(G.edges) == n * d / 2, "Should have n*d/2 edges"
-    assert nx.is_k_regular(G, d), "Should be d-regular"
-    assert nx.is_regular_expander(G), "Should be a regular expander"
-
-
-def test_random_regular_expander_explicit_construction():
-    pytest.importorskip("numpy")
-    pytest.importorskip("scipy")
-    G = nx.random_regular_expander_graph(d=4, n=5, seed=1729)
-
-    assert len(G) == 5 and len(G.edges) == 10, "Should be a complete graph"
-
-
-@pytest.mark.parametrize("graph_type", (nx.Graph, nx.DiGraph, nx.MultiDiGraph))
-def test_margulis_gabber_galil_graph_badinput(graph_type):
-    with pytest.raises(
-        nx.NetworkXError, match="`create_using` must be an undirected multigraph"
-    ):
-        nx.margulis_gabber_galil_graph(3, create_using=graph_type)
-
-
-@pytest.mark.parametrize("graph_type", (nx.Graph, nx.DiGraph, nx.MultiDiGraph))
-def test_chordal_cycle_graph_badinput(graph_type):
-    with pytest.raises(
-        nx.NetworkXError, match="`create_using` must be an undirected multigraph"
-    ):
-        nx.chordal_cycle_graph(3, create_using=graph_type)
-
-
-def test_paley_graph_badinput():
-    with pytest.raises(
-        nx.NetworkXError, match="`create_using` cannot be a multigraph."
-    ):
-        nx.paley_graph(3, create_using=nx.MultiGraph)
-
-
-def test_maybe_regular_expander_graph_badinput():
-    pytest.importorskip("numpy")
-
-    with pytest.raises(nx.NetworkXError, match="n must be a positive integer"):
-        nx.maybe_regular_expander_graph(n=-1, d=2)
-
-    with pytest.raises(nx.NetworkXError, match="d must be greater than or equal to 2"):
-        nx.maybe_regular_expander_graph(n=10, d=0)
-
-    with pytest.raises(nx.NetworkXError, match="Need n-1>= d to have room"):
-        nx.maybe_regular_expander_graph(n=5, d=6)
-
-
-def test_is_regular_expander_badinput():
-    pytest.importorskip("numpy")
-    pytest.importorskip("scipy")
-
-    with pytest.raises(nx.NetworkXError, match="epsilon must be non negative"):
-        nx.is_regular_expander(nx.Graph(), epsilon=-1)
-
-
-def test_random_regular_expander_badinput():
-    pytest.importorskip("numpy")
-    pytest.importorskip("scipy")
-
-    with pytest.raises(nx.NetworkXError, match="n must be a positive integer"):
-        nx.random_regular_expander_graph(n=-1, d=2)
-
-    with pytest.raises(nx.NetworkXError, match="d must be greater than or equal to 2"):
-        nx.random_regular_expander_graph(n=10, d=0)
-
-    with pytest.raises(nx.NetworkXError, match="Need n-1>= d to have room"):
-        nx.random_regular_expander_graph(n=5, d=6)
-
-    with pytest.raises(nx.NetworkXError, match="epsilon must be non negative"):
-        nx.random_regular_expander_graph(n=4, d=2, epsilon=-1)