okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_connectivity.py

@@ -1,199 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms import approximation as approx
-
-
-def test_global_node_connectivity():
-    # Figure 1 chapter on Connectivity
-    G = nx.Graph()
-    G.add_edges_from(
-        [
-            (1, 2),
-            (1, 3),
-            (1, 4),
-            (1, 5),
-            (2, 3),
-            (2, 6),
-            (3, 4),
-            (3, 6),
-            (4, 6),
-            (4, 7),
-            (5, 7),
-            (6, 8),
-            (6, 9),
-            (7, 8),
-            (7, 10),
-            (8, 11),
-            (9, 10),
-            (9, 11),
-            (10, 11),
-        ]
-    )
-    assert 2 == approx.local_node_connectivity(G, 1, 11)
-    assert 2 == approx.node_connectivity(G)
-    assert 2 == approx.node_connectivity(G, 1, 11)
-
-
-def test_white_harary1():
-    # Figure 1b white and harary (2001)
-    # A graph with high adhesion (edge connectivity) and low cohesion
-    # (node connectivity)
-    G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
-    G.remove_node(7)
-    for i in range(4, 7):
-        G.add_edge(0, i)
-    G = nx.disjoint_union(G, nx.complete_graph(4))
-    G.remove_node(G.order() - 1)
-    for i in range(7, 10):
-        G.add_edge(0, i)
-    assert 1 == approx.node_connectivity(G)
-
-
-def test_complete_graphs():
-    for n in range(5, 25, 5):
-        G = nx.complete_graph(n)
-        assert n - 1 == approx.node_connectivity(G)
-        assert n - 1 == approx.node_connectivity(G, 0, 3)
-
-
-def test_empty_graphs():
-    for k in range(5, 25, 5):
-        G = nx.empty_graph(k)
-        assert 0 == approx.node_connectivity(G)
-        assert 0 == approx.node_connectivity(G, 0, 3)
-
-
-def test_petersen():
-    G = nx.petersen_graph()
-    assert 3 == approx.node_connectivity(G)
-    assert 3 == approx.node_connectivity(G, 0, 5)
-
-
-# Approximation fails with tutte graph
-# def test_tutte():
-#    G = nx.tutte_graph()
-#    assert_equal(3, approx.node_connectivity(G))
-
-
-def test_dodecahedral():
-    G = nx.dodecahedral_graph()
-    assert 3 == approx.node_connectivity(G)
-    assert 3 == approx.node_connectivity(G, 0, 5)
-
-
-def test_octahedral():
-    G = nx.octahedral_graph()
-    assert 4 == approx.node_connectivity(G)
-    assert 4 == approx.node_connectivity(G, 0, 5)
-
-
-# Approximation can fail with icosahedral graph depending
-# on iteration order.
-# def test_icosahedral():
-#    G=nx.icosahedral_graph()
-#    assert_equal(5, approx.node_connectivity(G))
-#    assert_equal(5, approx.node_connectivity(G, 0, 5))
-
-
-def test_only_source():
-    G = nx.complete_graph(5)
-    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, s=0)
-
-
-def test_only_target():
-    G = nx.complete_graph(5)
-    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, t=0)
-
-
-def test_missing_source():
-    G = nx.path_graph(4)
-    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, 10, 1)
-
-
-def test_missing_target():
-    G = nx.path_graph(4)
-    pytest.raises(nx.NetworkXError, approx.node_connectivity, G, 1, 10)
-
-
-def test_source_equals_target():
-    G = nx.complete_graph(5)
-    pytest.raises(nx.NetworkXError, approx.local_node_connectivity, G, 0, 0)
-
-
-def test_directed_node_connectivity():
-    G = nx.cycle_graph(10, create_using=nx.DiGraph())  # only one direction
-    D = nx.cycle_graph(10).to_directed()  # 2 reciprocal edges
-    assert 1 == approx.node_connectivity(G)
-    assert 1 == approx.node_connectivity(G, 1, 4)
-    assert 2 == approx.node_connectivity(D)
-    assert 2 == approx.node_connectivity(D, 1, 4)
-
-
-class TestAllPairsNodeConnectivityApprox:
-    @classmethod
-    def setup_class(cls):
-        cls.path = nx.path_graph(7)
-        cls.directed_path = nx.path_graph(7, create_using=nx.DiGraph())
-        cls.cycle = nx.cycle_graph(7)
-        cls.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
-        cls.gnp = nx.gnp_random_graph(30, 0.1)
-        cls.directed_gnp = nx.gnp_random_graph(30, 0.1, directed=True)
-        cls.K20 = nx.complete_graph(20)
-        cls.K10 = nx.complete_graph(10)
-        cls.K5 = nx.complete_graph(5)
-        cls.G_list = [
-            cls.path,
-            cls.directed_path,
-            cls.cycle,
-            cls.directed_cycle,
-            cls.gnp,
-            cls.directed_gnp,
-            cls.K10,
-            cls.K5,
-            cls.K20,
-        ]
-
-    def test_cycles(self):
-        K_undir = approx.all_pairs_node_connectivity(self.cycle)
-        for source in K_undir:
-            for target, k in K_undir[source].items():
-                assert k == 2
-        K_dir = approx.all_pairs_node_connectivity(self.directed_cycle)
-        for source in K_dir:
-            for target, k in K_dir[source].items():
-                assert k == 1
-
-    def test_complete(self):
-        for G in [self.K10, self.K5, self.K20]:
-            K = approx.all_pairs_node_connectivity(G)
-            for source in K:
-                for target, k in K[source].items():
-                    assert k == len(G) - 1
-
-    def test_paths(self):
-        K_undir = approx.all_pairs_node_connectivity(self.path)
-        for source in K_undir:
-            for target, k in K_undir[source].items():
-                assert k == 1
-        K_dir = approx.all_pairs_node_connectivity(self.directed_path)
-        for source in K_dir:
-            for target, k in K_dir[source].items():
-                if source < target:
-                    assert k == 1
-                else:
-                    assert k == 0
-
-    def test_cutoff(self):
-        for G in [self.K10, self.K5, self.K20]:
-            for mp in [2, 3, 4]:
-                paths = approx.all_pairs_node_connectivity(G, cutoff=mp)
-                for source in paths:
-                    for target, K in paths[source].items():
-                        assert K == mp
-
-    def test_all_pairs_connectivity_nbunch(self):
-        G = nx.complete_graph(5)
-        nbunch = [0, 2, 3]
-        C = approx.all_pairs_node_connectivity(G, nbunch=nbunch)
-        assert len(C) == len(nbunch)

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_density.py

@@ -1,146 +0,0 @@
-import pytest
-
-import networkx as nx
-import networkx.algorithms.approximation as approx
-
-
-def close_cliques_example(d=12, D=300, h=24, k=2):
-    """
-    Hard example from Harb, Elfarouk, Kent Quanrud, and Chandra Chekuri.
-    "Faster and scalable algorithms for densest subgraph and decomposition."
-    Advances in Neural Information Processing Systems 35 (2022): 26966-26979.
-    """
-    Kh = nx.complete_graph(h)
-    KdD = nx.complete_bipartite_graph(d, D)
-    G = nx.disjoint_union_all([KdD] + [Kh for _ in range(k)])
-    best_density = d * D / (d + D)  # of the complete bipartite graph
-    return G, best_density, set(KdD.nodes)
-
-
-@pytest.mark.parametrize("iterations", (1, 3))
-@pytest.mark.parametrize("n", range(4, 7))
-@pytest.mark.parametrize("method", ("greedy++", "fista"))
-def test_star(n, iterations, method):
-    if method == "fista":
-        pytest.importorskip("numpy")
-
-    G = nx.star_graph(n)
-    # The densest subgraph of a star network is the entire graph.
-    # The peeling algorithm would peel all the vertices with degree 1,
-    # and so should discover the densest subgraph in one iteration!
-    d, S = approx.densest_subgraph(G, iterations=iterations, method=method)
-
-    assert d == pytest.approx(G.number_of_edges() / G.number_of_nodes())
-    assert S == set(G)  # The entire graph!
-
-
-@pytest.mark.parametrize("method", ("greedy++", "fista"))
-def test_greedy_plus_plus_complete_graph(method):
-    if method == "fista":
-        pytest.importorskip("numpy")
-
-    G = nx.complete_graph(4)
-    # The density of a complete graph network is the entire graph: C(4, 2)/4
-    # where C(n, 2) is n*(n-1)//2. The peeling algorithm would find
-    # the densest subgraph in one iteration!
-    d, S = approx.densest_subgraph(G, iterations=1, method=method)
-
-    assert d == pytest.approx(6 / 4)  # The density, 4/5=0.8.
-    assert S == {0, 1, 2, 3}  # The entire graph!
-
-
-def test_greedy_plus_plus_close_cliques():
-    G, best_density, densest_set = close_cliques_example()
-    # NOTE: iterations=185 fails to ID the densest subgraph
-    greedy_pp, S_pp = approx.densest_subgraph(G, iterations=186, method="greedy++")
-
-    assert greedy_pp == pytest.approx(best_density)
-    assert S_pp == densest_set
-
-
-def test_fista_close_cliques():
-    pytest.importorskip("numpy")
-    G, best_density, best_set = close_cliques_example()
-    # NOTE: iterations=12 fails to ID the densest subgraph
-    density, dense_set = approx.densest_subgraph(G, iterations=13, method="fista")
-
-    assert density == pytest.approx(best_density)
-    assert dense_set == best_set
-
-
-def bipartite_and_clique_example(d=5, D=200, k=2):
-    """
-    Hard example from: Boob, Digvijay, Yu Gao, Richard Peng, Saurabh Sawlani,
-    Charalampos Tsourakakis, Di Wang, and Junxing Wang. "Flowless: Extracting
-    densest subgraphs without flow computations." In Proceedings of The Web
-    Conference 2020, pp. 573-583. 2020.
-    """
-    B = nx.complete_bipartite_graph(d, D)
-    H = [nx.complete_graph(d + 2) for _ in range(k)]
-    G = nx.disjoint_union_all([B] + H)
-
-    best_density = d * D / (d + D)  # of the complete bipartite graph
-    correct_one_round_density = (2 * d * D + (d + 1) * (d + 2) * k) / (
-        2 * d + 2 * D + 2 * k * (d + 2)
-    )
-    best_subgraph = set(B.nodes)
-    return G, best_density, best_subgraph, correct_one_round_density
-
-
-def test_greedy_plus_plus_bipartite_and_clique():
-    G, best_density, best_subgraph, correct_one_iter_density = (
-        bipartite_and_clique_example()
-    )
-    one_round_density, S_one = approx.densest_subgraph(
-        G, iterations=1, method="greedy++"
-    )
-    assert one_round_density == pytest.approx(correct_one_iter_density)
-    assert S_one == set(G.nodes)
-
-    ten_round_density, S_ten = approx.densest_subgraph(
-        G, iterations=10, method="greedy++"
-    )
-    assert ten_round_density == pytest.approx(best_density)
-    assert S_ten == best_subgraph
-
-
-def test_fista_bipartite_and_clique():
-    pytest.importorskip("numpy")
-    G, best_density, best_subgraph, _ = bipartite_and_clique_example()
-
-    ten_round_density, S_ten = approx.densest_subgraph(G, iterations=10, method="fista")
-    assert ten_round_density == pytest.approx(best_density)
-    assert S_ten == best_subgraph
-
-
-def test_fista_big_dataset():
-    pytest.importorskip("numpy")
-    G, best_density, best_subgraph = close_cliques_example(d=30, D=2000, h=60, k=20)
-
-    # Note: iterations=12 fails to identify densest subgraph
-    density, dense_set = approx.densest_subgraph(G, iterations=13, method="fista")
-
-    assert density == pytest.approx(best_density)
-    assert dense_set == best_subgraph
-
-
-@pytest.mark.parametrize("iterations", (1, 3))
-def test_greedy_plus_plus_edgeless_cornercase(iterations):
-    G = nx.Graph()
-    assert approx.densest_subgraph(G, iterations=iterations, method="greedy++") == (
-        0,
-        set(),
-    )
-    G.add_nodes_from(range(4))
-    assert approx.densest_subgraph(G, iterations=iterations, method="greedy++") == (
-        0,
-        set(),
-    )
-
-
-@pytest.mark.parametrize("labels", ((1, 2, 3), ("a", "b", "c")))
-def test_gh_8271(labels):
-    """Test for graphs with nonstandard node labels."""
-    pytest.importorskip("numpy")
-    G = nx.complete_graph(labels)
-    assert approx.densest_subgraph(G, method="fista") == (1, set(labels))

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_distance_measures.py

@@ -1,59 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.approximation.distance_measures` module."""
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms.approximation import diameter
-
-
-class TestDiameter:
-    """Unit tests for the approximate diameter function
-    :func:`~networkx.algorithms.approximation.distance_measures.diameter`.
-    """
-
-    def test_null_graph(self):
-        """Test empty graph."""
-        G = nx.null_graph()
-        with pytest.raises(
-            nx.NetworkXError, match="Expected non-empty NetworkX graph!"
-        ):
-            diameter(G)
-
-    def test_undirected_non_connected(self):
-        """Test an undirected disconnected graph."""
-        graph = nx.path_graph(10)
-        graph.remove_edge(3, 4)
-        with pytest.raises(nx.NetworkXError, match="Graph not connected."):
-            diameter(graph)
-
-    def test_directed_non_strongly_connected(self):
-        """Test a directed non strongly connected graph."""
-        graph = nx.path_graph(10, create_using=nx.DiGraph())
-        with pytest.raises(nx.NetworkXError, match="DiGraph not strongly connected."):
-            diameter(graph)
-
-    def test_complete_undirected_graph(self):
-        """Test a complete undirected graph."""
-        graph = nx.complete_graph(10)
-        assert diameter(graph) == 1
-
-    def test_complete_directed_graph(self):
-        """Test a complete directed graph."""
-        graph = nx.complete_graph(10, create_using=nx.DiGraph())
-        assert diameter(graph) == 1
-
-    def test_undirected_path_graph(self):
-        """Test an undirected path graph with 10 nodes."""
-        graph = nx.path_graph(10)
-        assert diameter(graph) == 9
-
-    def test_directed_path_graph(self):
-        """Test a directed path graph with 10 nodes."""
-        graph = nx.path_graph(10).to_directed()
-        assert diameter(graph) == 9
-
-    def test_single_node(self):
-        """Test a graph which contains just a node."""
-        graph = nx.Graph()
-        graph.add_node(1)
-        assert diameter(graph) == 0

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/tests/test_dominating_set.py

@@ -1,78 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms.approximation import (
-    min_edge_dominating_set,
-    min_weighted_dominating_set,
-)
-
-
-class TestMinWeightDominatingSet:
-    def test_min_weighted_dominating_set(self):
-        graph = nx.Graph()
-        graph.add_edge(1, 2)
-        graph.add_edge(1, 5)
-        graph.add_edge(2, 3)
-        graph.add_edge(2, 5)
-        graph.add_edge(3, 4)
-        graph.add_edge(3, 6)
-        graph.add_edge(5, 6)
-
-        vertices = {1, 2, 3, 4, 5, 6}
-        # due to ties, this might be hard to test tight bounds
-        dom_set = min_weighted_dominating_set(graph)
-        for vertex in vertices - dom_set:
-            neighbors = set(graph.neighbors(vertex))
-            assert len(neighbors & dom_set) > 0, "Non dominating set found!"
-
-    def test_star_graph(self):
-        """Tests that an approximate dominating set for the star graph,
-        even when the center node does not have the smallest integer
-        label, gives just the center node.
-
-        For more information, see #1527.
-
-        """
-        # Create a star graph in which the center node has the highest
-        # label instead of the lowest.
-        G = nx.star_graph(10)
-        G = nx.relabel_nodes(G, {0: 9, 9: 0})
-        assert min_weighted_dominating_set(G) == {9}
-
-    def test_null_graph(self):
-        """Tests that the unique dominating set for the null graph is an empty set"""
-        G = nx.Graph()
-        assert min_weighted_dominating_set(G) == set()
-
-    def test_min_edge_dominating_set(self):
-        graph = nx.path_graph(5)
-        dom_set = min_edge_dominating_set(graph)
-
-        # this is a crappy way to test, but good enough for now.
-        for edge in graph.edges():
-            if edge in dom_set:
-                continue
-            else:
-                u, v = edge
-                found = False
-                for dom_edge in dom_set:
-                    found |= u == dom_edge[0] or u == dom_edge[1]
-                assert found, "Non adjacent edge found!"
-
-        graph = nx.complete_graph(10)
-        dom_set = min_edge_dominating_set(graph)
-
-        # this is a crappy way to test, but good enough for now.
-        for edge in graph.edges():
-            if edge in dom_set:
-                continue
-            else:
-                u, v = edge
-                found = False
-                for dom_edge in dom_set:
-                    found |= u == dom_edge[0] or u == dom_edge[1]
-                assert found, "Non adjacent edge found!"
-
-        graph = nx.Graph()  # empty Networkx graph
-        with pytest.raises(ValueError, match="Expected non-empty NetworkX graph!"):
-            min_edge_dominating_set(graph)