okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/community/tests/test_asyn_fluid.py

@@ -1,147 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx import Graph, NetworkXError
-from networkx.algorithms.community import asyn_fluidc
-
-
-@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
-def test_raises_on_directed_and_multigraphs(graph_constructor):
-    G = graph_constructor([(0, 1), (1, 2)])
-    with pytest.raises(nx.NetworkXNotImplemented):
-        nx.community.asyn_fluidc(G, 1)
-
-
-def test_exceptions():
-    test = Graph()
-    test.add_node("a")
-    pytest.raises(NetworkXError, asyn_fluidc, test, "hi")
-    pytest.raises(NetworkXError, asyn_fluidc, test, -1)
-    pytest.raises(NetworkXError, asyn_fluidc, test, 3)
-    with pytest.raises(ValueError, match="must be greater than 0"):
-        asyn_fluidc(test, 1, max_iter=0)
-    test.add_node("b")
-    pytest.raises(NetworkXError, asyn_fluidc, test, 1)
-
-
-def test_single_node():
-    test = Graph()
-
-    test.add_node("a")
-
-    # ground truth
-    ground_truth = {frozenset(["a"])}
-
-    communities = asyn_fluidc(test, 1)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_two_nodes():
-    test = Graph()
-
-    test.add_edge("a", "b")
-
-    # ground truth
-    ground_truth = {frozenset(["a"]), frozenset(["b"])}
-
-    communities = asyn_fluidc(test, 2)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_two_clique_communities():
-    test = Graph()
-
-    # c1
-    test.add_edge("a", "b")
-    test.add_edge("a", "c")
-    test.add_edge("b", "c")
-
-    # connection
-    test.add_edge("c", "d")
-
-    # c2
-    test.add_edge("d", "e")
-    test.add_edge("d", "f")
-    test.add_edge("f", "e")
-
-    # ground truth
-    ground_truth = {frozenset(["a", "c", "b"]), frozenset(["e", "d", "f"])}
-
-    communities = asyn_fluidc(test, 2, seed=7)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_five_clique_ring():
-    test = Graph()
-
-    # c1
-    test.add_edge("1a", "1b")
-    test.add_edge("1a", "1c")
-    test.add_edge("1a", "1d")
-    test.add_edge("1b", "1c")
-    test.add_edge("1b", "1d")
-    test.add_edge("1c", "1d")
-
-    # c2
-    test.add_edge("2a", "2b")
-    test.add_edge("2a", "2c")
-    test.add_edge("2a", "2d")
-    test.add_edge("2b", "2c")
-    test.add_edge("2b", "2d")
-    test.add_edge("2c", "2d")
-
-    # c3
-    test.add_edge("3a", "3b")
-    test.add_edge("3a", "3c")
-    test.add_edge("3a", "3d")
-    test.add_edge("3b", "3c")
-    test.add_edge("3b", "3d")
-    test.add_edge("3c", "3d")
-
-    # c4
-    test.add_edge("4a", "4b")
-    test.add_edge("4a", "4c")
-    test.add_edge("4a", "4d")
-    test.add_edge("4b", "4c")
-    test.add_edge("4b", "4d")
-    test.add_edge("4c", "4d")
-
-    # c5
-    test.add_edge("5a", "5b")
-    test.add_edge("5a", "5c")
-    test.add_edge("5a", "5d")
-    test.add_edge("5b", "5c")
-    test.add_edge("5b", "5d")
-    test.add_edge("5c", "5d")
-
-    # connections
-    test.add_edge("1a", "2c")
-    test.add_edge("2a", "3c")
-    test.add_edge("3a", "4c")
-    test.add_edge("4a", "5c")
-    test.add_edge("5a", "1c")
-
-    # ground truth
-    ground_truth = {
-        frozenset(["1a", "1b", "1c", "1d"]),
-        frozenset(["2a", "2b", "2c", "2d"]),
-        frozenset(["3a", "3b", "3c", "3d"]),
-        frozenset(["4a", "4b", "4c", "4d"]),
-        frozenset(["5a", "5b", "5c", "5d"]),
-    }
-
-    communities = asyn_fluidc(test, 5, seed=9)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_asyn_fluidc_max_iter():
-    """Check that setting `max_iter` stops the algorithm early."""
-    test = nx.barbell_graph(3, 2)
-
-    c1 = asyn_fluidc(test, 2, max_iter=1, seed=42)
-    c2 = asyn_fluidc(test, 2, max_iter=100, seed=42)
-    assert {map(frozenset, c1)} != {map(frozenset, c2)}

package/runtime/python/okstra_vendor/networkx/algorithms/community/tests/test_bipartitions.py

@@ -1,157 +0,0 @@
-from itertools import permutations
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms.community import (
-    greedy_node_swap_bipartition,
-    kernighan_lin_bisection,
-)
-
-
-def assert_partition_equal(x, y):
-    assert set(map(frozenset, x)) == set(map(frozenset, y))
-
-
-def test_partition():
-    G = nx.barbell_graph(3, 0)
-    split = kernighan_lin_bisection(G)
-    assert_partition_equal(split, [{0, 1, 2}, {3, 4, 5}])
-
-
-def test_partition_argument():
-    G = nx.barbell_graph(3, 0)
-    partition = [{0, 1, 2}, {3, 4, 5}]
-    split = kernighan_lin_bisection(G, partition)
-    assert_partition_equal(split, partition)
-
-
-def test_partition_argument_non_integer_nodes():
-    G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
-    partition = ({"A", "B"}, {"C", "D"})
-    split = kernighan_lin_bisection(G, partition)
-    assert_partition_equal(split, partition)
-
-
-def test_seed_argument():
-    G = nx.barbell_graph(3, 0)
-    split = kernighan_lin_bisection(G, seed=1)
-    assert_partition_equal(split, [{0, 1, 2}, {3, 4, 5}])
-
-
-def test_non_disjoint_partition():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.barbell_graph(3, 0)
-        partition = ({0, 1, 2}, {2, 3, 4, 5})
-        kernighan_lin_bisection(G, partition)
-
-
-def test_kernighan_lin_too_many_blocks():
-    with pytest.raises(nx.NetworkXError):
-        G = nx.barbell_graph(3, 0)
-        partition = ({0, 1}, {2}, {3, 4, 5})
-        kernighan_lin_bisection(G, partition)
-
-
-def test_multigraph():
-    G = nx.cycle_graph(4)
-    M = nx.MultiGraph(G.edges())
-    M.add_edges_from(G.edges())
-    M.remove_edge(1, 2)
-    for labels in permutations(range(4)):
-        mapping = dict(zip(M, labels))
-        A, B = kernighan_lin_bisection(nx.relabel_nodes(M, mapping), seed=0)
-        assert_partition_equal(
-            [A, B], [{mapping[0], mapping[1]}, {mapping[2], mapping[3]}]
-        )
-
-
-def test_max_iter_argument():
-    G = nx.Graph(
-        [
-            ("A", "B", {"weight": 1}),
-            ("A", "C", {"weight": 2}),
-            ("A", "D", {"weight": 3}),
-            ("A", "E", {"weight": 2}),
-            ("A", "F", {"weight": 4}),
-            ("B", "C", {"weight": 1}),
-            ("B", "D", {"weight": 4}),
-            ("B", "E", {"weight": 2}),
-            ("B", "F", {"weight": 1}),
-            ("C", "D", {"weight": 3}),
-            ("C", "E", {"weight": 2}),
-            ("C", "F", {"weight": 1}),
-            ("D", "E", {"weight": 4}),
-            ("D", "F", {"weight": 3}),
-            ("E", "F", {"weight": 2}),
-        ]
-    )
-    partition = ({"A", "B", "C"}, {"D", "E", "F"})
-    split = kernighan_lin_bisection(G, partition, max_iter=1)
-    assert_partition_equal(split, ({"A", "F", "C"}, {"D", "E", "B"}))
-
-
-def test_weight_function():
-    G = nx.cycle_graph(4)
-
-    def my_weight(u, v, d):
-        if u == 2 and v == 3:
-            return None
-        return u + v
-
-    split = kernighan_lin_bisection(G, weight=my_weight)
-    assert_partition_equal(split, ({1, 2}, {0, 3}))
-
-
-## Test Spectral Modularity Bipartition
-
-
-def test_spectral_bipartition():
-    pytest.importorskip("scipy")
-    G = nx.barbell_graph(3, 0)
-    split = nx.community.spectral_modularity_bipartition(G)
-    soln = ({3, 4, 5}, {0, 1, 2})
-    assert set(map(frozenset, split)) == set(map(frozenset, soln))
-
-
-def test_karate_club():
-    pytest.importorskip("scipy")
-    G = nx.karate_club_graph()
-    MrHi = {v for v, club in G.nodes.data("club") if club == "Mr. Hi"}
-    Officer = {v for v, club in G.nodes.data("club") if club == "Officer"}
-    split = nx.community.spectral_modularity_bipartition(G)
-
-    # spectral method misplaces member 8
-    MrHi.remove(8)
-    Officer.add(8)
-    soln = (MrHi, Officer)
-    assert set(map(frozenset, split)) == set(map(frozenset, soln))
-
-
-## Test Node Swap Greedy Bipartition
-
-
-def test_greedy_bipartition():
-    G = nx.barbell_graph(3, 0)
-    split = nx.community.greedy_node_swap_bipartition(G)
-    soln = ({0, 1, 2}, {3, 4, 5})
-    assert set(map(frozenset, split)) == set(map(frozenset, soln))
-
-
-def test_greedy_non_disjoint_partition():
-    G = nx.barbell_graph(3, 0)
-    split = ({0, 1, 2}, {2, 3, 4, 5})
-    with pytest.raises(nx.NetworkXError):
-        nx.community.greedy_node_swap_bipartition(G, init_split=split)
-
-
-def test_greedy_node_swap_too_many_blocks():
-    G = nx.barbell_graph(3, 0)
-    split = ({0, 1}, {2}, {3, 4, 5})
-    with pytest.raises(nx.NetworkXError):
-        nx.community.greedy_node_swap_bipartition(G, init_split=split)
-
-
-def test_greedy_multigraph_disallowed():
-    with pytest.raises(nx.NetworkXNotImplemented):
-        nx.community.greedy_node_swap_bipartition(nx.MultiGraph())

package/runtime/python/okstra_vendor/networkx/algorithms/community/tests/test_centrality.py

@@ -1,85 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.community.centrality`
-module.
-
-"""
-
-from operator import itemgetter
-
-import networkx as nx
-
-
-def set_of_sets(iterable):
-    return set(map(frozenset, iterable))
-
-
-def validate_communities(result, expected):
-    assert set_of_sets(result) == set_of_sets(expected)
-
-
-def validate_possible_communities(result, *expected):
-    assert any(set_of_sets(result) == set_of_sets(p) for p in expected)
-
-
-class TestGirvanNewman:
-    """Unit tests for the
-    :func:`networkx.algorithms.community.centrality.girvan_newman`
-    function.
-
-    """
-
-    def test_no_edges(self):
-        G = nx.empty_graph(3)
-        communities = list(nx.community.girvan_newman(G))
-        assert len(communities) == 1
-        validate_communities(communities[0], [{0}, {1}, {2}])
-
-    def test_undirected(self):
-        # Start with the graph .-.-.-.
-        G = nx.path_graph(4)
-        communities = list(nx.community.girvan_newman(G))
-        assert len(communities) == 3
-        # After one removal, we get the graph .-. .-.
-        validate_communities(communities[0], [{0, 1}, {2, 3}])
-        # After the next, we get the graph .-. . ., but there are two
-        # symmetric possible versions.
-        validate_possible_communities(
-            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
-        )
-        # After the last removal, we always get the empty graph.
-        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
-
-    def test_directed(self):
-        G = nx.DiGraph(nx.path_graph(4))
-        communities = list(nx.community.girvan_newman(G))
-        assert len(communities) == 3
-        validate_communities(communities[0], [{0, 1}, {2, 3}])
-        validate_possible_communities(
-            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
-        )
-        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
-
-    def test_selfloops(self):
-        G = nx.path_graph(4)
-        G.add_edge(0, 0)
-        G.add_edge(2, 2)
-        communities = list(nx.community.girvan_newman(G))
-        assert len(communities) == 3
-        validate_communities(communities[0], [{0, 1}, {2, 3}])
-        validate_possible_communities(
-            communities[1], [{0}, {1}, {2, 3}], [{0, 1}, {2}, {3}]
-        )
-        validate_communities(communities[2], [{0}, {1}, {2}, {3}])
-
-    def test_most_valuable_edge(self):
-        G = nx.Graph()
-        G.add_weighted_edges_from([(0, 1, 3), (1, 2, 2), (2, 3, 1)])
-        # Let the most valuable edge be the one with the highest weight.
-
-        def heaviest(G):
-            return max(G.edges(data="weight"), key=itemgetter(2))[:2]
-
-        communities = list(nx.community.girvan_newman(G, heaviest))
-        assert len(communities) == 3
-        validate_communities(communities[0], [{0}, {1, 2, 3}])
-        validate_communities(communities[1], [{0}, {1}, {2, 3}])
-        validate_communities(communities[2], [{0}, {1}, {2}, {3}])

package/runtime/python/okstra_vendor/networkx/algorithms/community/tests/test_divisive.py

@@ -1,106 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-def test_edge_betweenness_partition():
-    G = nx.barbell_graph(3, 0)
-    C = nx.community.edge_betweenness_partition(G, 2)
-    answer = [{0, 1, 2}, {3, 4, 5}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    G = nx.barbell_graph(3, 1)
-    C = nx.community.edge_betweenness_partition(G, 3)
-    answer = [{0, 1, 2}, {4, 5, 6}, {3}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    C = nx.community.edge_betweenness_partition(G, 7)
-    answer = [{n} for n in G]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    C = nx.community.edge_betweenness_partition(G, 1)
-    assert C == [set(G)]
-
-    C = nx.community.edge_betweenness_partition(G, 1, weight="weight")
-    assert C == [set(G)]
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_betweenness_partition(G, 0)
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_betweenness_partition(G, -1)
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_betweenness_partition(G, 10)
-
-
-def test_edge_current_flow_betweenness_partition():
-    pytest.importorskip("scipy")
-
-    G = nx.barbell_graph(3, 0)
-    C = nx.community.edge_current_flow_betweenness_partition(G, 2)
-    answer = [{0, 1, 2}, {3, 4, 5}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    G = nx.barbell_graph(3, 1)
-    C = nx.community.edge_current_flow_betweenness_partition(G, 2)
-    answers = [[{0, 1, 2, 3}, {4, 5, 6}], [{0, 1, 2}, {3, 4, 5, 6}]]
-    assert len(C) == len(answers[0])
-    assert any(all(s in answer for s in C) for answer in answers)
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 3)
-    answer = [{0, 1, 2}, {4, 5, 6}, {3}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 4)
-    answers = [[{1, 2}, {4, 5, 6}, {3}, {0}], [{0, 1, 2}, {5, 6}, {3}, {4}]]
-    assert len(C) == len(answers[0])
-    assert any(all(s in answer for s in C) for answer in answers)
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 5)
-    answer = [{1, 2}, {5, 6}, {3}, {0}, {4}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 6)
-    answers = [[{2}, {5, 6}, {3}, {0}, {4}, {1}], [{1, 2}, {6}, {3}, {0}, {4}, {5}]]
-    assert len(C) == len(answers[0])
-    assert any(all(s in answer for s in C) for answer in answers)
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 7)
-    answer = [{n} for n in G]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 1)
-    assert C == [set(G)]
-
-    C = nx.community.edge_current_flow_betweenness_partition(G, 1, weight="weight")
-    assert C == [set(G)]
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_current_flow_betweenness_partition(G, 0)
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_current_flow_betweenness_partition(G, -1)
-
-    with pytest.raises(nx.NetworkXError):
-        nx.community.edge_current_flow_betweenness_partition(G, 10)
-
-    N = 10
-    G = nx.empty_graph(N)
-    for i in range(2, N - 1):
-        C = nx.community.edge_current_flow_betweenness_partition(G, i)
-        assert C == [{n} for n in G]

package/runtime/python/okstra_vendor/networkx/algorithms/community/tests/test_kclique.py

@@ -1,91 +0,0 @@
-from itertools import combinations
-
-import pytest
-
-import networkx as nx
-
-
-def test_overlapping_K5():
-    G = nx.Graph()
-    G.add_edges_from(combinations(range(5), 2))  # Add a five clique
-    G.add_edges_from(combinations(range(2, 7), 2))  # Add another five clique
-    c = list(nx.community.k_clique_communities(G, 4))
-    assert c == [frozenset(range(7))]
-    c = set(nx.community.k_clique_communities(G, 5))
-    assert c == {frozenset(range(5)), frozenset(range(2, 7))}
-
-
-def test_isolated_K5():
-    G = nx.Graph()
-    G.add_edges_from(combinations(range(5), 2))  # Add a five clique
-    G.add_edges_from(combinations(range(5, 10), 2))  # Add another five clique
-    c = set(nx.community.k_clique_communities(G, 5))
-    assert c == {frozenset(range(5)), frozenset(range(5, 10))}
-
-
-class TestZacharyKarateClub:
-    def setup_method(self):
-        self.G = nx.karate_club_graph()
-
-    def _check_communities(self, k, expected):
-        communities = set(nx.community.k_clique_communities(self.G, k))
-        assert communities == expected
-
-    def test_k2(self):
-        # clique percolation with k=2 is just connected components
-        expected = {frozenset(self.G)}
-        self._check_communities(2, expected)
-
-    def test_k3(self):
-        comm1 = [
-            0,
-            1,
-            2,
-            3,
-            7,
-            8,
-            12,
-            13,
-            14,
-            15,
-            17,
-            18,
-            19,
-            20,
-            21,
-            22,
-            23,
-            26,
-            27,
-            28,
-            29,
-            30,
-            31,
-            32,
-            33,
-        ]
-        comm2 = [0, 4, 5, 6, 10, 16]
-        comm3 = [24, 25, 31]
-        expected = {frozenset(comm1), frozenset(comm2), frozenset(comm3)}
-        self._check_communities(3, expected)
-
-    def test_k4(self):
-        expected = {
-            frozenset([0, 1, 2, 3, 7, 13]),
-            frozenset([8, 32, 30, 33]),
-            frozenset([32, 33, 29, 23]),
-        }
-        self._check_communities(4, expected)
-
-    def test_k5(self):
-        expected = {frozenset([0, 1, 2, 3, 7, 13])}
-        self._check_communities(5, expected)
-
-    def test_k6(self):
-        expected = set()
-        self._check_communities(6, expected)
-
-
-def test_bad_k():
-    with pytest.raises(nx.NetworkXError):
-        list(nx.community.k_clique_communities(nx.Graph(), 1))