okstra 0.113.0 → 0.115.0

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

@@ -1,259 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx import approximate_current_flow_betweenness_centrality as approximate_cfbc
-from networkx import edge_current_flow_betweenness_centrality as edge_current_flow
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-class TestFlowBetweennessCentrality:
-    def test_K4_normalized(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        b_answer = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        G.add_edge(0, 1, weight=0.5, other=0.3)
-        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight=None)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        wb_answer = {0: 0.2222222, 1: 0.2222222, 2: 0.30555555, 3: 0.30555555}
-        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight="weight")
-        for n in sorted(G):
-            assert b[n] == pytest.approx(wb_answer[n], abs=1e-7)
-        wb_answer = {0: 0.2051282, 1: 0.2051282, 2: 0.33974358, 3: 0.33974358}
-        b = nx.current_flow_betweenness_centrality(G, normalized=True, weight="other")
-        for n in sorted(G):
-            assert b[n] == pytest.approx(wb_answer[n], abs=1e-7)
-
-    def test_K4(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        for solver in ["full", "lu", "cg"]:
-            b = nx.current_flow_betweenness_centrality(
-                G, normalized=False, solver=solver
-            )
-            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
-            for n in sorted(G):
-                assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P4_normalized(self):
-        """Betweenness centrality: P4 normalized"""
-        G = nx.path_graph(4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        b_answer = {0: 0, 1: 2.0 / 3, 2: 2.0 / 3, 3: 0}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P4(self):
-        """Betweenness centrality: P4"""
-        G = nx.path_graph(4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=False)
-        b_answer = {0: 0, 1: 2, 2: 2, 3: 0}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_star(self):
-        """Betweenness centrality: star"""
-        G = nx.Graph()
-        nx.add_star(G, ["a", "b", "c", "d"])
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        b_answer = {"a": 1.0, "b": 0.0, "c": 0.0, "d": 0.0}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_solvers2(self):
-        """Betweenness centrality: alternate solvers"""
-        G = nx.complete_graph(4)
-        for solver in ["full", "lu", "cg"]:
-            b = nx.current_flow_betweenness_centrality(
-                G, normalized=False, solver=solver
-            )
-            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
-            for n in sorted(G):
-                assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-
-class TestApproximateFlowBetweennessCentrality:
-    def test_K4_normalized(self):
-        "Approximate current-flow betweenness centrality: K4 normalized"
-        G = nx.complete_graph(4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        epsilon = 0.1
-        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
-        for n in sorted(G):
-            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
-
-    def test_K4(self):
-        "Approximate current-flow betweenness centrality: K4"
-        G = nx.complete_graph(4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=False)
-        epsilon = 0.1
-        ba = approximate_cfbc(G, normalized=False, epsilon=0.5 * epsilon)
-        for n in sorted(G):
-            np.testing.assert_allclose(b[n], ba[n], atol=epsilon * len(G) ** 2)
-
-    def test_star(self):
-        "Approximate current-flow betweenness centrality: star"
-        G = nx.Graph()
-        nx.add_star(G, ["a", "b", "c", "d"])
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        epsilon = 0.1
-        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
-        for n in sorted(G):
-            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
-
-    def test_grid(self):
-        "Approximate current-flow betweenness centrality: 2d grid"
-        G = nx.grid_2d_graph(4, 4)
-        b = nx.current_flow_betweenness_centrality(G, normalized=True)
-        epsilon = 0.1
-        ba = approximate_cfbc(G, normalized=True, epsilon=0.5 * epsilon)
-        for n in sorted(G):
-            np.testing.assert_allclose(b[n], ba[n], atol=epsilon)
-
-    def test_seed(self):
-        G = nx.complete_graph(4)
-        b = approximate_cfbc(G, normalized=False, epsilon=0.05, seed=1)
-        b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
-        for n in sorted(G):
-            np.testing.assert_allclose(b[n], b_answer[n], atol=0.1)
-
-    def test_solvers(self):
-        "Approximate current-flow betweenness centrality: solvers"
-        G = nx.complete_graph(4)
-        epsilon = 0.1
-        for solver in ["full", "lu", "cg"]:
-            b = approximate_cfbc(
-                G, normalized=False, solver=solver, epsilon=0.5 * epsilon
-            )
-            b_answer = {0: 0.75, 1: 0.75, 2: 0.75, 3: 0.75}
-            for n in sorted(G):
-                np.testing.assert_allclose(b[n], b_answer[n], atol=epsilon)
-
-    def test_lower_kmax(self):
-        G = nx.complete_graph(4)
-        with pytest.raises(nx.NetworkXError, match="Increase kmax or epsilon"):
-            nx.approximate_current_flow_betweenness_centrality(G, kmax=4)
-
-    def test_sample_weight_positive_effect(self):
-        G = nx.complete_graph(4)
-        b1 = approximate_cfbc(G, epsilon=0.1, seed=42)
-        b2 = approximate_cfbc(G, epsilon=0.1, sample_weight=2.0, seed=42)
-        assert len(b1) == len(b2) == 4
-        for node in G.nodes():
-            assert node in b1 and node in b2
-            assert isinstance(b1[node], float) and isinstance(b2[node], float)
-
-    def test_sample_weight_validation(self):
-        G = nx.complete_graph(4)
-
-        with pytest.raises(
-            nx.NetworkXError,
-            match="Sample weight must be positive. Got sample_weight=-1.0",
-        ):
-            approximate_cfbc(G, sample_weight=-1.0)
-
-        with pytest.raises(
-            nx.NetworkXError,
-            match="Sample weight must be positive. Got sample_weight=0.0",
-        ):
-            approximate_cfbc(G, sample_weight=0.0)
-
-        result = approximate_cfbc(G, sample_weight=0.1, seed=42)
-        assert len(result) == 4
-
-    def test_epsilon_validation(self):
-        G = nx.complete_graph(4)
-
-        with pytest.raises(
-            nx.NetworkXError, match="Epsilon must be positive. Got epsilon=-0.1"
-        ):
-            approximate_cfbc(G, epsilon=-0.1)
-
-        with pytest.raises(
-            nx.NetworkXError, match="Epsilon must be positive. Got epsilon=0.0"
-        ):
-            approximate_cfbc(G, epsilon=0.0)
-
-    def test_normalization_edge_case_small_graph(self):
-        G = nx.path_graph(2)
-
-        result_norm = approximate_cfbc(G, normalized=True, seed=42)
-        result_unnorm = approximate_cfbc(G, normalized=False, seed=42)
-
-        assert len(result_norm) == 2
-        assert len(result_unnorm) == 2
-        assert all(v == 0.0 for v in result_norm.values())
-        assert all(v == 0.0 for v in result_unnorm.values())
-
-        G1 = nx.Graph()
-        G1.add_node(0)
-        result1 = approximate_cfbc(G1, normalized=True, seed=42)
-        assert result1 == {0: 0.0}
-
-    def test_sample_weight_interaction_with_kmax(self):
-        G = nx.complete_graph(4)
-
-        with pytest.raises(nx.NetworkXError, match="Number random pairs k>kmax"):
-            approximate_cfbc(G, sample_weight=10.0, epsilon=0.01, kmax=10)
-
-
-class TestWeightedFlowBetweennessCentrality:
-    pass
-
-
-class TestEdgeFlowBetweennessCentrality:
-    def test_K4(self):
-        """Edge flow betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = edge_current_flow(G, normalized=True)
-        b_answer = dict.fromkeys(G.edges(), 0.25)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_K4_normalized(self):
-        """Edge flow betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = edge_current_flow(G, normalized=False)
-        b_answer = dict.fromkeys(G.edges(), 0.75)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_C4(self):
-        """Edge flow betweenness centrality: C4"""
-        G = nx.cycle_graph(4)
-        b = edge_current_flow(G, normalized=False)
-        b_answer = {(0, 1): 1.25, (0, 3): 1.25, (1, 2): 1.25, (2, 3): 1.25}
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_P4(self):
-        """Edge betweenness centrality: P4"""
-        G = nx.path_graph(4)
-        b = edge_current_flow(G, normalized=False)
-        b_answer = {(0, 1): 1.5, (1, 2): 2.0, (2, 3): 1.5}
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-
-@pytest.mark.parametrize(
-    "centrality_func",
-    (
-        nx.current_flow_betweenness_centrality,
-        nx.edge_current_flow_betweenness_centrality,
-        nx.approximate_current_flow_betweenness_centrality,
-    ),
-)
-def test_unconnected_graphs_betweenness_centrality(centrality_func):
-    G = nx.Graph([(1, 2), (3, 4)])
-    G.add_node(5)
-    with pytest.raises(nx.NetworkXError, match="Graph not connected"):
-        centrality_func(G)

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

@@ -1,147 +0,0 @@
-import pytest
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-import networkx as nx
-from networkx import edge_current_flow_betweenness_centrality as edge_current_flow
-from networkx import (
-    edge_current_flow_betweenness_centrality_subset as edge_current_flow_subset,
-)
-
-
-class TestFlowBetweennessCentrality:
-    def test_K4_normalized(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_K4(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        # test weighted network
-        G.add_edge(0, 1, weight=0.5, other=0.3)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True, weight=None
-        )
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True, weight="other"
-        )
-        b_answer = nx.current_flow_betweenness_centrality(
-            G, normalized=True, weight="other"
-        )
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P4_normalized(self):
-        """Betweenness centrality: P4 normalized"""
-        G = nx.path_graph(4)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P4(self):
-        """Betweenness centrality: P4"""
-        G = nx.path_graph(4)
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_star(self):
-        """Betweenness centrality: star"""
-        G = nx.Graph()
-        nx.add_star(G, ["a", "b", "c", "d"])
-        b = nx.current_flow_betweenness_centrality_subset(
-            G, list(G), list(G), normalized=True
-        )
-        b_answer = nx.current_flow_betweenness_centrality(G, normalized=True)
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-
-# class TestWeightedFlowBetweennessCentrality():
-#     pass
-
-
-class TestEdgeFlowBetweennessCentrality:
-    def test_K4_normalized(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
-        b_answer = edge_current_flow(G, normalized=True)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_K4(self):
-        """Betweenness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=False)
-        b_answer = edge_current_flow(G, normalized=False)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-        # test weighted network
-        G.add_edge(0, 1, weight=0.5, other=0.3)
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=False, weight=None)
-        # weight is None => same as unweighted network
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=False)
-        b_answer = edge_current_flow(G, normalized=False)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-        b = edge_current_flow_subset(
-            G, list(G), list(G), normalized=False, weight="other"
-        )
-        b_answer = edge_current_flow(G, normalized=False, weight="other")
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_C4(self):
-        """Edge betweenness centrality: C4"""
-        G = nx.cycle_graph(4)
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
-        b_answer = edge_current_flow(G, normalized=True)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)
-
-    def test_P4(self):
-        """Edge betweenness centrality: P4"""
-        G = nx.path_graph(4)
-        b = edge_current_flow_subset(G, list(G), list(G), normalized=True)
-        b_answer = edge_current_flow(G, normalized=True)
-        for (s, t), v1 in b_answer.items():
-            v2 = b.get((s, t), b.get((t, s)))
-            assert v1 == pytest.approx(v2, abs=1e-7)

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

@@ -1,43 +0,0 @@
-import pytest
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-import networkx as nx
-
-
-class TestFlowClosenessCentrality:
-    def test_K4(self):
-        """Closeness centrality: K4"""
-        G = nx.complete_graph(4)
-        b = nx.current_flow_closeness_centrality(G)
-        b_answer = {0: 2.0 / 3, 1: 2.0 / 3, 2: 2.0 / 3, 3: 2.0 / 3}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_P4(self):
-        """Closeness centrality: P4"""
-        G = nx.path_graph(4)
-        b = nx.current_flow_closeness_centrality(G)
-        b_answer = {0: 1.0 / 6, 1: 1.0 / 4, 2: 1.0 / 4, 3: 1.0 / 6}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_star(self):
-        """Closeness centrality: star"""
-        G = nx.Graph()
-        nx.add_star(G, ["a", "b", "c", "d"])
-        b = nx.current_flow_closeness_centrality(G)
-        b_answer = {"a": 1.0 / 3, "b": 0.6 / 3, "c": 0.6 / 3, "d": 0.6 / 3}
-        for n in sorted(G):
-            assert b[n] == pytest.approx(b_answer[n], abs=1e-7)
-
-    def test_current_flow_closeness_centrality_not_connected(self):
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3])
-        with pytest.raises(nx.NetworkXError):
-            nx.current_flow_closeness_centrality(G)
-
-
-class TestWeightedFlowClosenessCentrality:
-    pass

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

@@ -1,144 +0,0 @@
-"""
-Unit tests for degree centrality.
-"""
-
-import pytest
-
-import networkx as nx
-
-
-class TestDegreeCentrality:
-    def setup_method(self):
-        self.K = nx.krackhardt_kite_graph()
-        self.P3 = nx.path_graph(3)
-        self.K5 = nx.complete_graph(5)
-
-        F = nx.Graph()  # Florentine families
-        F.add_edge("Acciaiuoli", "Medici")
-        F.add_edge("Castellani", "Peruzzi")
-        F.add_edge("Castellani", "Strozzi")
-        F.add_edge("Castellani", "Barbadori")
-        F.add_edge("Medici", "Barbadori")
-        F.add_edge("Medici", "Ridolfi")
-        F.add_edge("Medici", "Tornabuoni")
-        F.add_edge("Medici", "Albizzi")
-        F.add_edge("Medici", "Salviati")
-        F.add_edge("Salviati", "Pazzi")
-        F.add_edge("Peruzzi", "Strozzi")
-        F.add_edge("Peruzzi", "Bischeri")
-        F.add_edge("Strozzi", "Ridolfi")
-        F.add_edge("Strozzi", "Bischeri")
-        F.add_edge("Ridolfi", "Tornabuoni")
-        F.add_edge("Tornabuoni", "Guadagni")
-        F.add_edge("Albizzi", "Ginori")
-        F.add_edge("Albizzi", "Guadagni")
-        F.add_edge("Bischeri", "Guadagni")
-        F.add_edge("Guadagni", "Lamberteschi")
-        self.F = F
-
-        G = nx.DiGraph()
-        G.add_edge(0, 5)
-        G.add_edge(1, 5)
-        G.add_edge(2, 5)
-        G.add_edge(3, 5)
-        G.add_edge(4, 5)
-        G.add_edge(5, 6)
-        G.add_edge(5, 7)
-        G.add_edge(5, 8)
-        self.G = G
-
-    def test_degree_centrality_1(self):
-        d = nx.degree_centrality(self.K5)
-        exact = dict(zip(range(5), [1] * 5))
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    def test_degree_centrality_2(self):
-        d = nx.degree_centrality(self.P3)
-        exact = {0: 0.5, 1: 1, 2: 0.5}
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    def test_degree_centrality_3(self):
-        d = nx.degree_centrality(self.K)
-        exact = {
-            0: 0.444,
-            1: 0.444,
-            2: 0.333,
-            3: 0.667,
-            4: 0.333,
-            5: 0.556,
-            6: 0.556,
-            7: 0.333,
-            8: 0.222,
-            9: 0.111,
-        }
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(float(f"{dc:.3f}"), abs=1e-7)
-
-    def test_degree_centrality_4(self):
-        d = nx.degree_centrality(self.F)
-        names = sorted(self.F.nodes())
-        dcs = [
-            0.071,
-            0.214,
-            0.143,
-            0.214,
-            0.214,
-            0.071,
-            0.286,
-            0.071,
-            0.429,
-            0.071,
-            0.214,
-            0.214,
-            0.143,
-            0.286,
-            0.214,
-        ]
-        exact = dict(zip(names, dcs))
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(float(f"{dc:.3f}"), abs=1e-7)
-
-    def test_indegree_centrality(self):
-        d = nx.in_degree_centrality(self.G)
-        exact = {
-            0: 0.0,
-            1: 0.0,
-            2: 0.0,
-            3: 0.0,
-            4: 0.0,
-            5: 0.625,
-            6: 0.125,
-            7: 0.125,
-            8: 0.125,
-        }
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    def test_outdegree_centrality(self):
-        d = nx.out_degree_centrality(self.G)
-        exact = {
-            0: 0.125,
-            1: 0.125,
-            2: 0.125,
-            3: 0.125,
-            4: 0.125,
-            5: 0.375,
-            6: 0.0,
-            7: 0.0,
-            8: 0.0,
-        }
-        for n, dc in d.items():
-            assert exact[n] == pytest.approx(dc, abs=1e-7)
-
-    def test_small_graph_centrality(self):
-        G = nx.empty_graph(create_using=nx.DiGraph)
-        assert {} == nx.degree_centrality(G)
-        assert {} == nx.out_degree_centrality(G)
-        assert {} == nx.in_degree_centrality(G)
-
-        G = nx.empty_graph(1, create_using=nx.DiGraph)
-        assert {0: 1} == nx.degree_centrality(G)
-        assert {0: 1} == nx.out_degree_centrality(G)
-        assert {0: 1} == nx.in_degree_centrality(G)

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

@@ -1,73 +0,0 @@
-import networkx as nx
-
-
-def small_ego_G():
-    """The sample network from https://arxiv.org/pdf/1310.6753v1.pdf"""
-    edges = [
-        ("a", "b"),
-        ("a", "c"),
-        ("b", "c"),
-        ("b", "d"),
-        ("b", "e"),
-        ("b", "f"),
-        ("c", "d"),
-        ("c", "f"),
-        ("c", "h"),
-        ("d", "f"),
-        ("e", "f"),
-        ("f", "h"),
-        ("h", "j"),
-        ("h", "k"),
-        ("i", "j"),
-        ("i", "k"),
-        ("j", "k"),
-        ("u", "a"),
-        ("u", "b"),
-        ("u", "c"),
-        ("u", "d"),
-        ("u", "e"),
-        ("u", "f"),
-        ("u", "g"),
-        ("u", "h"),
-        ("u", "i"),
-        ("u", "j"),
-        ("u", "k"),
-    ]
-    G = nx.Graph()
-    G.add_edges_from(edges)
-
-    return G
-
-
-class TestDispersion:
-    def test_article(self):
-        """our algorithm matches article's"""
-        G = small_ego_G()
-        disp_uh = nx.dispersion(G, "u", "h", normalized=False)
-        disp_ub = nx.dispersion(G, "u", "b", normalized=False)
-        assert disp_uh == 4
-        assert disp_ub == 1
-
-    def test_results_length(self):
-        """there is a result for every node"""
-        G = small_ego_G()
-        disp = nx.dispersion(G)
-        disp_Gu = nx.dispersion(G, "u")
-        disp_uv = nx.dispersion(G, "u", "h")
-        assert len(disp) == len(G)
-        assert len(disp_Gu) == len(G) - 1
-        assert isinstance(disp_uv, float)
-
-    def test_dispersion_v_only(self):
-        G = small_ego_G()
-        disp_G_h = nx.dispersion(G, v="h", normalized=False)
-        disp_G_h_normalized = nx.dispersion(G, v="h", normalized=True)
-        assert disp_G_h == {"c": 0, "f": 0, "j": 0, "k": 0, "u": 4}
-        assert disp_G_h_normalized == {"c": 0.0, "f": 0.0, "j": 0.0, "k": 0.0, "u": 1.0}
-
-    def test_impossible_things(self):
-        G = nx.karate_club_graph()
-        disp = nx.dispersion(G)
-        for u in disp:
-            for v in disp[u]:
-                assert disp[u][v] >= 0