okstra 0.114.0 → 0.116.0

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

@@ -1,241 +0,0 @@
-from itertools import chain, combinations
-
-import pytest
-
-import networkx as nx
-
-
-def test_directed_not_supported():
-    with pytest.raises(nx.NetworkXNotImplemented):
-        # not supported for directed graphs
-        test = nx.DiGraph()
-        test.add_edge("a", "b")
-        test.add_edge("a", "c")
-        test.add_edge("b", "d")
-        result = nx.community.label_propagation_communities(test)
-
-
-def test_iterator_vs_iterable():
-    G = nx.empty_graph("a")
-    assert list(nx.community.label_propagation_communities(G)) == [{"a"}]
-    for community in nx.community.label_propagation_communities(G):
-        assert community == {"a"}
-    pytest.raises(TypeError, next, nx.community.label_propagation_communities(G))
-
-
-def test_one_node():
-    test = nx.Graph()
-    test.add_node("a")
-
-    # The expected communities are:
-    ground_truth = {frozenset(["a"])}
-
-    communities = nx.community.label_propagation_communities(test)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_unconnected_communities():
-    test = nx.Graph()
-    # community 1
-    test.add_edge("a", "c")
-    test.add_edge("a", "d")
-    test.add_edge("d", "c")
-    # community 2
-    test.add_edge("b", "e")
-    test.add_edge("e", "f")
-    test.add_edge("f", "b")
-
-    # The expected communities are:
-    ground_truth = {frozenset(["a", "c", "d"]), frozenset(["b", "e", "f"])}
-
-    communities = nx.community.label_propagation_communities(test)
-    result = {frozenset(c) for c in communities}
-    assert result == ground_truth
-
-
-def test_connected_communities():
-    test = nx.Graph()
-    # community 1
-    test.add_edge("a", "b")
-    test.add_edge("c", "a")
-    test.add_edge("c", "b")
-    test.add_edge("d", "a")
-    test.add_edge("d", "b")
-    test.add_edge("d", "c")
-    test.add_edge("e", "a")
-    test.add_edge("e", "b")
-    test.add_edge("e", "c")
-    test.add_edge("e", "d")
-    # community 2
-    test.add_edge("1", "2")
-    test.add_edge("3", "1")
-    test.add_edge("3", "2")
-    test.add_edge("4", "1")
-    test.add_edge("4", "2")
-    test.add_edge("4", "3")
-    test.add_edge("5", "1")
-    test.add_edge("5", "2")
-    test.add_edge("5", "3")
-    test.add_edge("5", "4")
-    # edge between community 1 and 2
-    test.add_edge("a", "1")
-    # community 3
-    test.add_edge("x", "y")
-    # community 4 with only a single node
-    test.add_node("z")
-
-    # The expected communities are:
-    ground_truth1 = {
-        frozenset(["a", "b", "c", "d", "e"]),
-        frozenset(["1", "2", "3", "4", "5"]),
-        frozenset(["x", "y"]),
-        frozenset(["z"]),
-    }
-    ground_truth2 = {
-        frozenset(["a", "b", "c", "d", "e", "1", "2", "3", "4", "5"]),
-        frozenset(["x", "y"]),
-        frozenset(["z"]),
-    }
-    ground_truth = (ground_truth1, ground_truth2)
-
-    communities = nx.community.label_propagation_communities(test)
-    result = {frozenset(c) for c in communities}
-    assert result in ground_truth
-
-
-def test_termination():
-    # ensure termination of asyn_lpa_communities in two cases
-    # that led to an endless loop in a previous version
-    test1 = nx.karate_club_graph()
-    test2 = nx.caveman_graph(2, 10)
-    test2.add_edges_from([(0, 20), (20, 10)])
-    nx.community.asyn_lpa_communities(test1)
-    nx.community.asyn_lpa_communities(test2)
-
-
-class TestAsynLpaCommunities:
-    def _check_communities(self, G, expected):
-        """Checks that the communities computed from the given graph ``G``
-        using the :func:`~networkx.asyn_lpa_communities` function match
-        the set of nodes given in ``expected``.
-
-        ``expected`` must be a :class:`set` of :class:`frozenset`
-        instances, each element of which is a node in the graph.
-
-        """
-        communities = nx.community.asyn_lpa_communities(G)
-        result = {frozenset(c) for c in communities}
-        assert result == expected
-
-    def test_null_graph(self):
-        G = nx.null_graph()
-        ground_truth = set()
-        self._check_communities(G, ground_truth)
-
-    def test_single_node(self):
-        G = nx.empty_graph(1)
-        ground_truth = {frozenset([0])}
-        self._check_communities(G, ground_truth)
-
-    def test_simple_communities(self):
-        # This graph is the disjoint union of two triangles.
-        G = nx.Graph(["ab", "ac", "bc", "de", "df", "fe"])
-        ground_truth = {frozenset("abc"), frozenset("def")}
-        self._check_communities(G, ground_truth)
-
-    def test_seed_argument(self):
-        G = nx.Graph(["ab", "ac", "bc", "de", "df", "fe"])
-        ground_truth = {frozenset("abc"), frozenset("def")}
-        communities = nx.community.asyn_lpa_communities(G, seed=1)
-        result = {frozenset(c) for c in communities}
-        assert result == ground_truth
-
-    def test_several_communities(self):
-        # This graph is the disjoint union of five triangles.
-        ground_truth = {frozenset(range(3 * i, 3 * (i + 1))) for i in range(5)}
-        edges = chain.from_iterable(combinations(c, 2) for c in ground_truth)
-        G = nx.Graph(edges)
-        self._check_communities(G, ground_truth)
-
-
-class TestFastLabelPropagationCommunities:
-    N = 100  # number of nodes
-    K = 15  # average node degree
-
-    def _check_communities(self, G, truth, weight=None, seed=42):
-        C = nx.community.fast_label_propagation_communities(G, weight=weight, seed=seed)
-        assert {frozenset(c) for c in C} == truth
-
-    def test_null_graph(self):
-        G = nx.null_graph()
-        truth = set()
-        self._check_communities(G, truth)
-
-    def test_empty_graph(self):
-        G = nx.empty_graph(self.N)
-        truth = {frozenset([i]) for i in G}
-        self._check_communities(G, truth)
-
-    def test_star_graph(self):
-        G = nx.star_graph(self.N)
-        truth = {frozenset(G)}
-        self._check_communities(G, truth)
-
-    def test_complete_graph(self):
-        G = nx.complete_graph(self.N)
-        truth = {frozenset(G)}
-        self._check_communities(G, truth)
-
-    def test_bipartite_graph(self):
-        G = nx.complete_bipartite_graph(self.N // 2, self.N // 2)
-        truth = {frozenset(G)}
-        self._check_communities(G, truth)
-
-    def test_random_graph(self):
-        G = nx.gnm_random_graph(self.N, self.N * self.K // 2, seed=42)
-        truth = {frozenset(G)}
-        self._check_communities(G, truth)
-
-    def test_disjoin_cliques(self):
-        G = nx.Graph(["ab", "AB", "AC", "BC", "12", "13", "14", "23", "24", "34"])
-        truth = {frozenset("ab"), frozenset("ABC"), frozenset("1234")}
-        self._check_communities(G, truth)
-
-    def test_ring_of_cliques(self):
-        N, K = self.N, self.K
-        G = nx.ring_of_cliques(N, K)
-        truth = {frozenset([K * i + k for k in range(K)]) for i in range(N)}
-        self._check_communities(G, truth)
-
-    def test_larger_graph(self):
-        G = nx.gnm_random_graph(100 * self.N, 50 * self.N * self.K, seed=42)
-        nx.community.fast_label_propagation_communities(G)
-
-    def test_graph_type(self):
-        G1 = nx.complete_graph(self.N, nx.MultiDiGraph())
-        G2 = nx.MultiGraph(G1)
-        G3 = nx.DiGraph(G1)
-        G4 = nx.Graph(G1)
-        truth = {frozenset(G1)}
-        self._check_communities(G1, truth)
-        self._check_communities(G2, truth)
-        self._check_communities(G3, truth)
-        self._check_communities(G4, truth)
-
-    def test_weight_argument(self):
-        G = nx.MultiDiGraph()
-        G.add_edge(1, 2, weight=1.41)
-        G.add_edge(2, 1, weight=1.41)
-        G.add_edge(2, 3)
-        G.add_edge(3, 4, weight=3.14)
-        truth = {frozenset({1, 2}), frozenset({3, 4})}
-        self._check_communities(G, truth, weight="weight")
-
-    def test_seed_argument(self):
-        G = nx.karate_club_graph()
-        C = nx.community.fast_label_propagation_communities(G, seed=2023)
-        truth = {frozenset(c) for c in C}
-        self._check_communities(G, truth, seed=2023)
-        # smoke test that seed=None works
-        C = nx.community.fast_label_propagation_communities(G, seed=None)

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

@@ -1,138 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms.community import leiden_communities, leiden_partitions
-
-# Leiden is not yet implemented by networkx, so only run tests in this file for
-# backends that implement Leiden.
-no_backends_for_leiden_communities = (
-    "not set(nx.config.backend_priority.algos) & leiden_communities.backends"
-)
-
-no_backends_for_leiden_partitions = (
-    "not set(nx.config.backend_priority.algos) & leiden_partitions.backends"
-)
-
-
-def test_leiden_with_nx_backend():
-    G = nx.karate_club_graph()
-    with pytest.raises(NotImplementedError):
-        nx.community.leiden_partitions(G, backend="networkx")
-    with pytest.raises(NotImplementedError):
-        nx.community.leiden_communities(G, backend="networkx")
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_modularity_increase():
-    G = nx.LFR_benchmark_graph(
-        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
-    )
-    partition = [{u} for u in G.nodes()]
-    mod = nx.community.modularity(G, partition)
-    partition = nx.community.leiden_communities(G)
-
-    assert nx.community.modularity(G, partition) > mod
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_valid_partition():
-    G = nx.LFR_benchmark_graph(
-        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
-    )
-    partition = nx.community.leiden_communities(G)
-
-    assert nx.community.is_partition(G, partition)
-
-
-@pytest.mark.skipif(no_backends_for_leiden_partitions)
-def test_partition_iterator():
-    G = nx.path_graph(15)
-    parts_iter = nx.community.leiden_partitions(G, seed=42)
-    first_part = next(parts_iter)
-    first_copy = [s.copy() for s in first_part]
-
-    # check 1st part stays fixed even after 2nd iteration (like gh-5901 in louvain)
-    assert first_copy[0] == first_part[0]
-    second_part = next(parts_iter)
-    assert first_copy[0] == first_part[0]
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_none_weight_param():
-    G = nx.karate_club_graph()
-    nx.set_edge_attributes(
-        G, {edge: i * i for i, edge in enumerate(G.edges)}, name="foo"
-    )
-
-    partition1 = nx.community.leiden_communities(G, weight=None, seed=2)
-    partition2 = nx.community.leiden_communities(G, weight="foo", seed=2)
-    partition3 = nx.community.leiden_communities(G, weight="weight", seed=2)
-
-    assert partition1 != partition2
-    assert partition2 != partition3
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_quality():
-    G = nx.LFR_benchmark_graph(
-        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
-    )
-    H = nx.MultiGraph(G)
-
-    partition = nx.community.leiden_communities(G)
-    partition2 = nx.community.leiden_communities(H)
-
-    quality = nx.community.partition_quality(G, partition)[0]
-    quality2 = nx.community.partition_quality(H, partition2)[0]
-
-    assert quality >= 0.65
-    assert quality2 >= 0.65
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_resolution():
-    G = nx.LFR_benchmark_graph(
-        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
-    )
-
-    partition1 = nx.community.leiden_communities(G, resolution=0.5, seed=12)
-    partition2 = nx.community.leiden_communities(G, seed=12)
-    partition3 = nx.community.leiden_communities(G, resolution=2, seed=12)
-
-    assert len(partition1) <= len(partition2)
-    assert len(partition2) <= len(partition3)
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_empty_graph():
-    G = nx.Graph()
-    G.add_nodes_from(range(5))
-    expected = [{0}, {1}, {2}, {3}, {4}]
-    assert nx.community.leiden_communities(G) == expected
-
-
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_directed_not_implemented():
-    G = nx.cycle_graph(4, create_using=nx.DiGraph)
-    with pytest.raises(nx.NetworkXNotImplemented):
-        nx.community.leiden_communities(G)
-
-
-@pytest.mark.skipif(no_backends_for_leiden_partitions)
-@pytest.mark.skipif(no_backends_for_leiden_communities)
-def test_max_level():
-    G = nx.LFR_benchmark_graph(
-        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
-    )
-    parts_iter = nx.community.leiden_partitions(G, seed=42)
-    for max_level, expected in enumerate(parts_iter, 1):
-        partition = nx.community.leiden_communities(G, max_level=max_level, seed=42)
-        assert partition == expected
-    assert max_level > 1  # Ensure we are actually testing max_level
-    # max_level is an upper limit; it's okay if we stop before it's hit.
-    partition = nx.community.leiden_communities(G, max_level=max_level + 1, seed=42)
-    assert partition == expected
-    with pytest.raises(
-        ValueError, match="max_level argument must be a positive integer"
-    ):
-        nx.community.leiden_communities(G, max_level=0)

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

@@ -1,76 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-def test_greedy_source_expansion_karate_club():
-    G = nx.karate_club_graph()
-
-    community = nx.community.greedy_source_expansion(G, source=16)
-
-    expected = {0, 4, 5, 6, 10, 16}
-
-    assert community == expected
-
-
-def test_greedy_source_expansion_cutoff():
-    G = nx.karate_club_graph()
-
-    community = nx.community.greedy_source_expansion(G, source=16, cutoff=3)
-
-    assert community == {5, 6, 16}
-
-
-def test_greedy_source_expansion_invalid_method():
-    G = nx.karate_club_graph()
-
-    with pytest.raises(ValueError):
-        nx.community.greedy_source_expansion(G, source=16, cutoff=3, method="invalid")
-
-
-def test_greedy_source_expansion_connected_component():
-    G_edges = [(0, 2), (0, 1), (1, 0), (2, 1), (2, 0), (3, 4), (4, 3)]
-    G = nx.Graph(G_edges)
-    expected = {0, 1, 2}
-    community = nx.community.greedy_source_expansion(G, source=0)
-    assert community == expected
-
-
-def test_greedy_source_expansion_directed_graph():
-    G_edges = [
-        (0, 2),
-        (0, 1),
-        (1, 0),
-        (2, 1),
-        (2, 0),
-        (3, 4),
-        (4, 3),
-        (4, 5),
-        (5, 3),
-        (5, 6),
-        (0, 6),
-    ]
-    G = nx.DiGraph(G_edges)
-
-    expected = {0, 1, 2, 6}
-    community = nx.community.greedy_source_expansion(G, source=0)
-    assert community == expected
-
-
-def test_greedy_source_expansion_multigraph():
-    G = nx.MultiGraph(nx.karate_club_graph())
-    G.add_edge(0, 1)
-    G.add_edge(0, 9)
-
-    expected = {0, 4, 5, 6, 10, 16}
-
-    community = nx.community.greedy_source_expansion(G, source=16)
-
-    assert community == expected
-
-
-def test_greedy_source_expansion_empty_graph():
-    G = nx.Graph()
-    G.add_nodes_from(range(5))
-    expected = {0}
-    assert nx.community.greedy_source_expansion(G, source=0) == expected