okstra 0.113.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/tests/test_eigenvector_centrality.py

@@ -1,186 +0,0 @@
-import math
-
-import pytest
-
-import networkx as nx
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-class TestEigenvectorCentrality:
-    def test_K5(self):
-        """Eigenvector centrality: K5"""
-        G = nx.complete_graph(5)
-        b = nx.eigenvector_centrality(G)
-        v = math.sqrt(1 / 5.0)
-        b_answer = dict.fromkeys(G, v)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        nstart = {n: 1 for n in G}
-        b = nx.eigenvector_centrality(G, nstart=nstart)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-        b = nx.eigenvector_centrality_numpy(G)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-3)
-
-    def test_P3(self):
-        """Eigenvector centrality: P3"""
-        G = nx.path_graph(3)
-        b_answer = {0: 0.5, 1: 0.7071, 2: 0.5}
-        b = nx.eigenvector_centrality_numpy(G)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-        b = nx.eigenvector_centrality(G)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_P3_unweighted(self):
-        """Eigenvector centrality: P3"""
-        G = nx.path_graph(3)
-        b_answer = {0: 0.5, 1: 0.7071, 2: 0.5}
-        b = nx.eigenvector_centrality_numpy(G, weight=None)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-4)
-
-    def test_maxiter(self):
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            G = nx.path_graph(3)
-            nx.eigenvector_centrality(G, max_iter=0)
-
-
-class TestEigenvectorCentralityDirected:
-    @classmethod
-    def setup_class(cls):
-        G = nx.DiGraph()
-
-        edges = [
-            (1, 2),
-            (1, 3),
-            (2, 4),
-            (3, 2),
-            (3, 5),
-            (4, 2),
-            (4, 5),
-            (4, 6),
-            (5, 6),
-            (5, 7),
-            (5, 8),
-            (6, 8),
-            (7, 1),
-            (7, 5),
-            (7, 8),
-            (8, 6),
-            (8, 7),
-        ]
-
-        G.add_edges_from(edges, weight=2.0)
-        cls.G = G.reverse()
-        cls.G.evc = [
-            0.25368793,
-            0.19576478,
-            0.32817092,
-            0.40430835,
-            0.48199885,
-            0.15724483,
-            0.51346196,
-            0.32475403,
-        ]
-
-        H = nx.DiGraph()
-
-        edges = [
-            (1, 2),
-            (1, 3),
-            (2, 4),
-            (3, 2),
-            (3, 5),
-            (4, 2),
-            (4, 5),
-            (4, 6),
-            (5, 6),
-            (5, 7),
-            (5, 8),
-            (6, 8),
-            (7, 1),
-            (7, 5),
-            (7, 8),
-            (8, 6),
-            (8, 7),
-        ]
-
-        G.add_edges_from(edges)
-        cls.H = G.reverse()
-        cls.H.evc = [
-            0.25368793,
-            0.19576478,
-            0.32817092,
-            0.40430835,
-            0.48199885,
-            0.15724483,
-            0.51346196,
-            0.32475403,
-        ]
-
-    def test_eigenvector_centrality_weighted(self):
-        G = self.G
-        p = nx.eigenvector_centrality(G)
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-4)
-
-    def test_eigenvector_centrality_weighted_numpy(self):
-        G = self.G
-        p = nx.eigenvector_centrality_numpy(G)
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-    def test_eigenvector_centrality_unweighted(self):
-        G = self.H
-        p = nx.eigenvector_centrality(G)
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-4)
-
-    def test_eigenvector_centrality_unweighted_numpy(self):
-        G = self.H
-        p = nx.eigenvector_centrality_numpy(G)
-        for a, b in zip(list(p.values()), self.G.evc):
-            assert a == pytest.approx(b, abs=1e-7)
-
-
-class TestEigenvectorCentralityExceptions:
-    def test_multigraph(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.eigenvector_centrality(nx.MultiGraph())
-
-    def test_multigraph_numpy(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.eigenvector_centrality_numpy(nx.MultiGraph())
-
-    def test_null(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.eigenvector_centrality(nx.Graph())
-
-    def test_null_numpy(self):
-        with pytest.raises(nx.NetworkXException):
-            nx.eigenvector_centrality_numpy(nx.Graph())
-
-    @pytest.mark.parametrize(
-        "G",
-        [
-            nx.empty_graph(3),
-            nx.DiGraph([(0, 1), (1, 2)]),
-        ],
-    )
-    def test_disconnected_numpy(self, G):
-        msg = "does not give consistent results for disconnected"
-        with pytest.raises(nx.AmbiguousSolution, match=msg):
-            nx.eigenvector_centrality_numpy(G)
-
-    def test_zero_nstart(self):
-        G = nx.Graph([(1, 2), (1, 3), (2, 3)])
-        with pytest.raises(
-            nx.NetworkXException, match="initial vector cannot have all zero values"
-        ):
-            nx.eigenvector_centrality(G, nstart={v: 0 for v in G})

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/tests/test_group.py

@@ -1,277 +0,0 @@
-"""
-Tests for Group Centrality Measures
-"""
-
-import pytest
-
-import networkx as nx
-
-
-class TestGroupBetweennessCentrality:
-    def test_group_betweenness_single_node(self):
-        """
-        Group betweenness centrality for single node group
-        """
-        G = nx.path_graph(5)
-        C = [1]
-        b = nx.group_betweenness_centrality(
-            G, C, weight=None, normalized=False, endpoints=False
-        )
-        b_answer = 3.0
-        assert b == b_answer
-
-    def test_group_betweenness_with_endpoints(self):
-        """
-        Group betweenness centrality for single node group
-        """
-        G = nx.path_graph(5)
-        C = [1]
-        b = nx.group_betweenness_centrality(
-            G, C, weight=None, normalized=False, endpoints=True
-        )
-        b_answer = 7.0
-        assert b == b_answer
-
-    def test_group_betweenness_normalized(self):
-        """
-        Group betweenness centrality for group with more than
-        1 node and normalized
-        """
-        G = nx.path_graph(5)
-        C = [1, 3]
-        b = nx.group_betweenness_centrality(
-            G, C, weight=None, normalized=True, endpoints=False
-        )
-        b_answer = 1.0
-        assert b == b_answer
-
-    def test_two_group_betweenness_value_zero(self):
-        """
-        Group betweenness centrality value of 0
-        """
-        G = nx.cycle_graph(7)
-        C = [[0, 1, 6], [0, 1, 5]]
-        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
-        b_answer = [0.0, 3.0]
-        assert b == b_answer
-
-    def test_group_betweenness_value_zero(self):
-        """
-        Group betweenness centrality value of 0
-        """
-        G = nx.cycle_graph(6)
-        C = [0, 1, 5]
-        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
-        b_answer = 0.0
-        assert b == b_answer
-
-    def test_group_betweenness_disconnected_graph(self):
-        """
-        Group betweenness centrality in a disconnected graph
-        """
-        G = nx.path_graph(5)
-        G.remove_edge(0, 1)
-        C = [1]
-        b = nx.group_betweenness_centrality(G, C, weight=None, normalized=False)
-        b_answer = 0.0
-        assert b == b_answer
-
-    def test_group_betweenness_node_not_in_graph(self):
-        """
-        Node(s) in C not in graph, raises NodeNotFound exception
-        """
-        with pytest.raises(nx.NodeNotFound):
-            nx.group_betweenness_centrality(nx.path_graph(5), [4, 7, 8])
-
-    def test_group_betweenness_directed_weighted(self):
-        """
-        Group betweenness centrality in a directed and weighted graph
-        """
-        G = nx.DiGraph()
-        G.add_edge(1, 0, weight=1)
-        G.add_edge(0, 2, weight=2)
-        G.add_edge(1, 2, weight=3)
-        G.add_edge(3, 1, weight=4)
-        G.add_edge(2, 3, weight=1)
-        G.add_edge(4, 3, weight=6)
-        G.add_edge(2, 4, weight=7)
-        C = [1, 2]
-        b = nx.group_betweenness_centrality(G, C, weight="weight", normalized=False)
-        b_answer = 5.0
-        assert b == b_answer
-
-
-class TestProminentGroup:
-    np = pytest.importorskip("numpy")
-    pd = pytest.importorskip("pandas")
-
-    def test_prominent_group_single_node(self):
-        """
-        Prominent group for single node
-        """
-        G = nx.path_graph(5)
-        k = 1
-        b, g = nx.prominent_group(G, k, normalized=False, endpoints=False)
-        b_answer, g_answer = 4.0, [2]
-        assert b == b_answer and g == g_answer
-
-    def test_prominent_group_with_c(self):
-        """
-        Prominent group without some nodes
-        """
-        G = nx.path_graph(5)
-        k = 1
-        b, g = nx.prominent_group(G, k, normalized=False, C=[2])
-        b_answer, g_answer = 3.0, [1]
-        assert b == b_answer and g == g_answer
-
-    def test_prominent_group_normalized_endpoints(self):
-        """
-        Prominent group with normalized result, with endpoints
-        """
-        G = nx.cycle_graph(7)
-        k = 2
-        b, g = nx.prominent_group(G, k, normalized=True, endpoints=True)
-        b_answer, g_answer = 1.7, [2, 5]
-        assert b == b_answer and g == g_answer
-
-    def test_prominent_group_disconnected_graph(self):
-        """
-        Prominent group of disconnected graph
-        """
-        G = nx.path_graph(6)
-        G.remove_edge(0, 1)
-        k = 1
-        b, g = nx.prominent_group(G, k, weight=None, normalized=False)
-        b_answer, g_answer = 4.0, [3]
-        assert b == b_answer and g == g_answer
-
-    def test_prominent_group_node_not_in_graph(self):
-        """
-        Node(s) in C not in graph, raises NodeNotFound exception
-        """
-        with pytest.raises(nx.NodeNotFound):
-            nx.prominent_group(nx.path_graph(5), 1, C=[10])
-
-    def test_group_betweenness_directed_weighted(self):
-        """
-        Group betweenness centrality in a directed and weighted graph
-        """
-        G = nx.DiGraph()
-        G.add_edge(1, 0, weight=1)
-        G.add_edge(0, 2, weight=2)
-        G.add_edge(1, 2, weight=3)
-        G.add_edge(3, 1, weight=4)
-        G.add_edge(2, 3, weight=1)
-        G.add_edge(4, 3, weight=6)
-        G.add_edge(2, 4, weight=7)
-        k = 2
-        b, g = nx.prominent_group(G, k, weight="weight", normalized=False)
-        b_answer, g_answer = 5.0, [1, 2]
-        assert b == b_answer and g == g_answer
-
-    def test_prominent_group_greedy_algorithm(self):
-        """
-        Group betweenness centrality in a greedy algorithm
-        """
-        G = nx.cycle_graph(7)
-        k = 2
-        b, g = nx.prominent_group(G, k, normalized=True, endpoints=True, greedy=True)
-        b_answer, g_answer = 1.7, [6, 3]
-        assert b == b_answer and g == g_answer
-
-
-class TestGroupClosenessCentrality:
-    def test_group_closeness_single_node(self):
-        """
-        Group closeness centrality for a single node group
-        """
-        G = nx.path_graph(5)
-        c = nx.group_closeness_centrality(G, [1])
-        c_answer = nx.closeness_centrality(G, 1)
-        assert c == c_answer
-
-    def test_group_closeness_disconnected(self):
-        """
-        Group closeness centrality for a disconnected graph
-        """
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3, 4])
-        c = nx.group_closeness_centrality(G, [1, 2])
-        c_answer = 0
-        assert c == c_answer
-
-    def test_group_closeness_multiple_node(self):
-        """
-        Group closeness centrality for a group with more than
-        1 node
-        """
-        G = nx.path_graph(4)
-        c = nx.group_closeness_centrality(G, [1, 2])
-        c_answer = 1
-        assert c == c_answer
-
-    def test_group_closeness_node_not_in_graph(self):
-        """
-        Node(s) in S not in graph, raises NodeNotFound exception
-        """
-        with pytest.raises(nx.NodeNotFound):
-            nx.group_closeness_centrality(nx.path_graph(5), [6, 7, 8])
-
-
-class TestGroupDegreeCentrality:
-    def test_group_degree_centrality_single_node(self):
-        """
-        Group degree centrality for a single node group
-        """
-        G = nx.path_graph(4)
-        d = nx.group_degree_centrality(G, [1])
-        d_answer = nx.degree_centrality(G)[1]
-        assert d == d_answer
-
-    def test_group_degree_centrality_multiple_node(self):
-        """
-        Group degree centrality for group with more than
-        1 node
-        """
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
-        G.add_edges_from(
-            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
-        )
-        d = nx.group_degree_centrality(G, [1, 2])
-        d_answer = 1
-        assert d == d_answer
-
-    def test_group_in_degree_centrality(self):
-        """
-        Group in-degree centrality in a DiGraph
-        """
-        G = nx.DiGraph()
-        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
-        G.add_edges_from(
-            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
-        )
-        d = nx.group_in_degree_centrality(G, [1, 2])
-        d_answer = 0
-        assert d == d_answer
-
-    def test_group_out_degree_centrality(self):
-        """
-        Group out-degree centrality in a DiGraph
-        """
-        G = nx.DiGraph()
-        G.add_nodes_from([1, 2, 3, 4, 5, 6, 7, 8])
-        G.add_edges_from(
-            [(1, 2), (1, 3), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5)]
-        )
-        d = nx.group_out_degree_centrality(G, [1, 2])
-        d_answer = 1
-        assert d == d_answer
-
-    def test_group_degree_centrality_node_not_in_graph(self):
-        """
-        Node(s) in S not in graph, raises NetworkXError
-        """
-        with pytest.raises(nx.NetworkXError):
-            nx.group_degree_centrality(nx.path_graph(5), [6, 7, 8])

package/runtime/python/okstra_vendor/networkx/algorithms/centrality/tests/test_harmonic_centrality.py

@@ -1,122 +0,0 @@
-"""
-Tests for degree centrality.
-"""
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms.centrality import harmonic_centrality
-
-
-class TestClosenessCentrality:
-    @classmethod
-    def setup_class(cls):
-        cls.P3 = nx.path_graph(3)
-        cls.P4 = nx.path_graph(4)
-        cls.K5 = nx.complete_graph(5)
-
-        cls.C4 = nx.cycle_graph(4)
-        cls.C4_directed = nx.cycle_graph(4, create_using=nx.DiGraph)
-
-        cls.C5 = nx.cycle_graph(5)
-
-        cls.T = nx.balanced_tree(r=2, h=2)
-
-        cls.Gb = nx.DiGraph()
-        cls.Gb.add_edges_from([(0, 1), (0, 2), (0, 4), (2, 1), (2, 3), (4, 3)])
-
-    def test_p3_harmonic(self):
-        c = harmonic_centrality(self.P3)
-        d = {0: 1.5, 1: 2, 2: 1.5}
-        for n in sorted(self.P3):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_p4_harmonic(self):
-        c = harmonic_centrality(self.P4)
-        d = {0: 1.8333333, 1: 2.5, 2: 2.5, 3: 1.8333333}
-        for n in sorted(self.P4):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_clique_complete(self):
-        c = harmonic_centrality(self.K5)
-        d = {0: 4, 1: 4, 2: 4, 3: 4, 4: 4}
-        for n in sorted(self.P3):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_cycle_C4(self):
-        c = harmonic_centrality(self.C4)
-        d = {0: 2.5, 1: 2.5, 2: 2.5, 3: 2.5}
-        for n in sorted(self.C4):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_cycle_C5(self):
-        c = harmonic_centrality(self.C5)
-        d = {0: 3, 1: 3, 2: 3, 3: 3, 4: 3, 5: 4}
-        for n in sorted(self.C5):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_bal_tree(self):
-        c = harmonic_centrality(self.T)
-        d = {0: 4.0, 1: 4.1666, 2: 4.1666, 3: 2.8333, 4: 2.8333, 5: 2.8333, 6: 2.8333}
-        for n in sorted(self.T):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_exampleGraph(self):
-        c = harmonic_centrality(self.Gb)
-        d = {0: 0, 1: 2, 2: 1, 3: 2.5, 4: 1}
-        for n in sorted(self.Gb):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_weighted_harmonic(self):
-        XG = nx.DiGraph()
-        XG.add_weighted_edges_from(
-            [
-                ("a", "b", 10),
-                ("d", "c", 5),
-                ("a", "c", 1),
-                ("e", "f", 2),
-                ("f", "c", 1),
-                ("a", "f", 3),
-            ]
-        )
-        c = harmonic_centrality(XG, distance="weight")
-        d = {"a": 0, "b": 0.1, "c": 2.533, "d": 0, "e": 0, "f": 0.83333}
-        for n in sorted(XG):
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_empty(self):
-        G = nx.DiGraph()
-        c = harmonic_centrality(G, distance="weight")
-        d = {}
-        assert c == d
-
-    def test_singleton(self):
-        G = nx.DiGraph()
-        G.add_node(0)
-        c = harmonic_centrality(G, distance="weight")
-        d = {0: 0}
-        assert c == d
-
-    def test_cycle_c4_directed(self):
-        c = harmonic_centrality(self.C4_directed, nbunch=[0, 1], sources=[1, 2])
-        d = {0: 0.833, 1: 0.333}
-        for n in [0, 1]:
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_cycle_c4_directed_subset(self):
-        c = harmonic_centrality(self.C4_directed, nbunch=[0, 1])
-        d = 1.833
-        for n in [0, 1]:
-            assert c[n] == pytest.approx(d, abs=1e-3)
-
-    def test_p3_harmonic_subset(self):
-        c = harmonic_centrality(self.P3, sources=[0, 1])
-        d = {0: 1, 1: 1, 2: 1.5}
-        for n in self.P3:
-            assert c[n] == pytest.approx(d[n], abs=1e-3)
-
-    def test_p4_harmonic_subset(self):
-        c = harmonic_centrality(self.P4, nbunch=[2, 3], sources=[0, 1])
-        d = {2: 1.5, 3: 0.8333333}
-        for n in [2, 3]:
-            assert c[n] == pytest.approx(d[n], abs=1e-3)