okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/test_mixing.py

@@ -1,174 +0,0 @@
-import pytest
-
-import networkx as nx
-
-from .base_test import BaseTestAttributeMixing, BaseTestDegreeMixing
-
-np = pytest.importorskip("numpy")
-
-
-class TestDegreeMixingDict(BaseTestDegreeMixing):
-    def test_degree_mixing_dict_undirected(self):
-        d = nx.degree_mixing_dict(self.P4)
-        d_result = {1: {2: 2}, 2: {1: 2, 2: 2}}
-        assert d == d_result
-
-    def test_degree_mixing_dict_undirected_normalized(self):
-        d = nx.degree_mixing_dict(self.P4, normalized=True)
-        d_result = {1: {2: 1.0 / 3}, 2: {1: 1.0 / 3, 2: 1.0 / 3}}
-        assert d == d_result
-
-    def test_degree_mixing_dict_directed(self):
-        d = nx.degree_mixing_dict(self.D)
-        d_result = {1: {3: 2}, 2: {1: 1, 3: 1}, 3: {}}
-        assert d == d_result
-
-    def test_degree_mixing_dict_multigraph(self):
-        d = nx.degree_mixing_dict(self.M)
-        d_result = {1: {2: 1}, 2: {1: 1, 3: 3}, 3: {2: 3}}
-        assert d == d_result
-
-    def test_degree_mixing_dict_weighted(self):
-        d = nx.degree_mixing_dict(self.W, weight="weight")
-        d_result = {0.5: {1.5: 1}, 1.5: {1.5: 6, 0.5: 1}}
-        assert d == d_result
-
-
-class TestDegreeMixingMatrix(BaseTestDegreeMixing):
-    def test_degree_mixing_matrix_undirected(self):
-        # fmt: off
-        a_result = np.array([[0, 2],
-                             [2, 2]]
-                            )
-        # fmt: on
-        a = nx.degree_mixing_matrix(self.P4, normalized=False)
-        np.testing.assert_equal(a, a_result)
-        a = nx.degree_mixing_matrix(self.P4)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_degree_mixing_matrix_directed(self):
-        # fmt: off
-        a_result = np.array([[0, 0, 2],
-                             [1, 0, 1],
-                             [0, 0, 0]]
-                            )
-        # fmt: on
-        a = nx.degree_mixing_matrix(self.D, normalized=False)
-        np.testing.assert_equal(a, a_result)
-        a = nx.degree_mixing_matrix(self.D)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_degree_mixing_matrix_multigraph(self):
-        # fmt: off
-        a_result = np.array([[0, 1, 0],
-                             [1, 0, 3],
-                             [0, 3, 0]]
-                            )
-        # fmt: on
-        a = nx.degree_mixing_matrix(self.M, normalized=False)
-        np.testing.assert_equal(a, a_result)
-        a = nx.degree_mixing_matrix(self.M)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_degree_mixing_matrix_selfloop(self):
-        # fmt: off
-        a_result = np.array([[2]])
-        # fmt: on
-        a = nx.degree_mixing_matrix(self.S, normalized=False)
-        np.testing.assert_equal(a, a_result)
-        a = nx.degree_mixing_matrix(self.S)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_degree_mixing_matrix_weighted(self):
-        a_result = np.array([[0.0, 1.0], [1.0, 6.0]])
-        a = nx.degree_mixing_matrix(self.W, weight="weight", normalized=False)
-        np.testing.assert_equal(a, a_result)
-        a = nx.degree_mixing_matrix(self.W, weight="weight")
-        np.testing.assert_equal(a, a_result / float(a_result.sum()))
-
-    def test_degree_mixing_matrix_mapping(self):
-        a_result = np.array([[6.0, 1.0], [1.0, 0.0]])
-        mapping = {0.5: 1, 1.5: 0}
-        a = nx.degree_mixing_matrix(
-            self.W, weight="weight", normalized=False, mapping=mapping
-        )
-        np.testing.assert_equal(a, a_result)
-
-
-class TestAttributeMixingDict(BaseTestAttributeMixing):
-    def test_attribute_mixing_dict_undirected(self):
-        d = nx.attribute_mixing_dict(self.G, "fish")
-        d_result = {
-            "one": {"one": 2, "red": 1},
-            "two": {"two": 2, "blue": 1},
-            "red": {"one": 1},
-            "blue": {"two": 1},
-        }
-        assert d == d_result
-
-    def test_attribute_mixing_dict_directed(self):
-        d = nx.attribute_mixing_dict(self.D, "fish")
-        d_result = {
-            "one": {"one": 1, "red": 1},
-            "two": {"two": 1, "blue": 1},
-            "red": {},
-            "blue": {},
-        }
-        assert d == d_result
-
-    def test_attribute_mixing_dict_multigraph(self):
-        d = nx.attribute_mixing_dict(self.M, "fish")
-        d_result = {"one": {"one": 4}, "two": {"two": 2}}
-        assert d == d_result
-
-
-class TestAttributeMixingMatrix(BaseTestAttributeMixing):
-    def test_attribute_mixing_matrix_undirected(self):
-        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
-        a_result = np.array([[2, 0, 1, 0], [0, 2, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]])
-        a = nx.attribute_mixing_matrix(
-            self.G, "fish", mapping=mapping, normalized=False
-        )
-        np.testing.assert_equal(a, a_result)
-        a = nx.attribute_mixing_matrix(self.G, "fish", mapping=mapping)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_attribute_mixing_matrix_directed(self):
-        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
-        a_result = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]])
-        a = nx.attribute_mixing_matrix(
-            self.D, "fish", mapping=mapping, normalized=False
-        )
-        np.testing.assert_equal(a, a_result)
-        a = nx.attribute_mixing_matrix(self.D, "fish", mapping=mapping)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_attribute_mixing_matrix_multigraph(self):
-        mapping = {"one": 0, "two": 1, "red": 2, "blue": 3}
-        a_result = np.array([[4, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
-        a = nx.attribute_mixing_matrix(
-            self.M, "fish", mapping=mapping, normalized=False
-        )
-        np.testing.assert_equal(a, a_result)
-        a = nx.attribute_mixing_matrix(self.M, "fish", mapping=mapping)
-        np.testing.assert_equal(a, a_result / a_result.sum())
-
-    def test_attribute_mixing_matrix_negative(self):
-        mapping = {-2: 0, -3: 1, -4: 2}
-        a_result = np.array([[4.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
-        a = nx.attribute_mixing_matrix(
-            self.N, "margin", mapping=mapping, normalized=False
-        )
-        np.testing.assert_equal(a, a_result)
-        a = nx.attribute_mixing_matrix(self.N, "margin", mapping=mapping)
-        np.testing.assert_equal(a, a_result / float(a_result.sum()))
-
-    def test_attribute_mixing_matrix_float(self):
-        mapping = {0.5: 1, 1.5: 0}
-        a_result = np.array([[6.0, 1.0], [1.0, 0.0]])
-        a = nx.attribute_mixing_matrix(
-            self.F, "margin", mapping=mapping, normalized=False
-        )
-        np.testing.assert_equal(a, a_result)
-        a = nx.attribute_mixing_matrix(self.F, "margin", mapping=mapping)
-        np.testing.assert_equal(a, a_result / a_result.sum())

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/test_neighbor_degree.py

@@ -1,107 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestAverageNeighbor:
-    def test_degree_p4(self):
-        G = nx.path_graph(4)
-        answer = {0: 2, 1: 1.5, 2: 1.5, 3: 2}
-        nd = nx.average_neighbor_degree(G)
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D)
-        assert nd == answer
-
-        D = nx.DiGraph(G.edges(data=True))
-        nd = nx.average_neighbor_degree(D)
-        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
-        nd = nx.average_neighbor_degree(D, "in", "out")
-        assert nd == {0: 0, 1: 1, 2: 1, 3: 1}
-        nd = nx.average_neighbor_degree(D, "out", "in")
-        assert nd == {0: 1, 1: 1, 2: 1, 3: 0}
-        nd = nx.average_neighbor_degree(D, "in", "in")
-        assert nd == {0: 0, 1: 0, 2: 1, 3: 1}
-
-    def test_degree_p4_weighted(self):
-        G = nx.path_graph(4)
-        G[1][2]["weight"] = 4
-        answer = {0: 2, 1: 1.8, 2: 1.8, 3: 2}
-        nd = nx.average_neighbor_degree(G, weight="weight")
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D, weight="weight")
-        assert nd == answer
-
-        D = nx.DiGraph(G.edges(data=True))
-        nd = nx.average_neighbor_degree(D, weight="weight")
-        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
-        nd = nx.average_neighbor_degree(D, "out", "out", weight="weight")
-        assert nd == {0: 1, 1: 1, 2: 0, 3: 0}
-        nd = nx.average_neighbor_degree(D, "in", "in", weight="weight")
-        assert nd == {0: 0, 1: 0, 2: 1, 3: 1}
-        nd = nx.average_neighbor_degree(D, "in", "out", weight="weight")
-        assert nd == {0: 0, 1: 1, 2: 1, 3: 1}
-        nd = nx.average_neighbor_degree(D, "out", "in", weight="weight")
-        assert nd == {0: 1, 1: 1, 2: 1, 3: 0}
-        nd = nx.average_neighbor_degree(D, source="in+out", weight="weight")
-        assert nd == {0: 1.0, 1: 1.0, 2: 0.8, 3: 1.0}
-        nd = nx.average_neighbor_degree(D, target="in+out", weight="weight")
-        assert nd == {0: 2.0, 1: 2.0, 2: 1.0, 3: 0.0}
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D, weight="weight")
-        assert nd == answer
-        nd = nx.average_neighbor_degree(D, source="out", target="out", weight="weight")
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D, source="in", target="in", weight="weight")
-        assert nd == answer
-
-    def test_degree_k4(self):
-        G = nx.complete_graph(4)
-        answer = {0: 3, 1: 3, 2: 3, 3: 3}
-        nd = nx.average_neighbor_degree(G)
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D)
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D)
-        assert nd == answer
-
-        D = G.to_directed()
-        nd = nx.average_neighbor_degree(D, source="in", target="in")
-        assert nd == answer
-
-    def test_degree_k4_nodes(self):
-        G = nx.complete_graph(4)
-        answer = {1: 3.0, 2: 3.0}
-        nd = nx.average_neighbor_degree(G, nodes=[1, 2])
-        assert nd == answer
-
-    def test_degree_barrat(self):
-        G = nx.star_graph(5)
-        G.add_edges_from([(5, 6), (5, 7), (5, 8), (5, 9)])
-        G[0][5]["weight"] = 5
-        nd = nx.average_neighbor_degree(G)[5]
-        assert nd == 1.8
-        nd = nx.average_neighbor_degree(G, weight="weight")[5]
-        assert nd == pytest.approx(3.222222, abs=1e-5)
-
-    def test_error_invalid_source_target(self):
-        G = nx.path_graph(4)
-        with pytest.raises(nx.NetworkXError):
-            nx.average_neighbor_degree(G, "error")
-        with pytest.raises(nx.NetworkXError):
-            nx.average_neighbor_degree(G, "in", "error")
-        G = G.to_directed()
-        with pytest.raises(nx.NetworkXError):
-            nx.average_neighbor_degree(G, "error")
-        with pytest.raises(nx.NetworkXError):
-            nx.average_neighbor_degree(G, "in", "error")

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/tests/test_pairs.py

@@ -1,87 +0,0 @@
-import networkx as nx
-
-from .base_test import BaseTestAttributeMixing, BaseTestDegreeMixing
-
-
-class TestAttributeMixingXY(BaseTestAttributeMixing):
-    def test_node_attribute_xy_undirected(self):
-        attrxy = sorted(nx.node_attribute_xy(self.G, "fish"))
-        attrxy_result = sorted(
-            [
-                ("one", "one"),
-                ("one", "one"),
-                ("two", "two"),
-                ("two", "two"),
-                ("one", "red"),
-                ("red", "one"),
-                ("blue", "two"),
-                ("two", "blue"),
-            ]
-        )
-        assert attrxy == attrxy_result
-
-    def test_node_attribute_xy_undirected_nodes(self):
-        attrxy = sorted(nx.node_attribute_xy(self.G, "fish", nodes=["one", "yellow"]))
-        attrxy_result = sorted([])
-        assert attrxy == attrxy_result
-
-    def test_node_attribute_xy_directed(self):
-        attrxy = sorted(nx.node_attribute_xy(self.D, "fish"))
-        attrxy_result = sorted(
-            [("one", "one"), ("two", "two"), ("one", "red"), ("two", "blue")]
-        )
-        assert attrxy == attrxy_result
-
-    def test_node_attribute_xy_multigraph(self):
-        attrxy = sorted(nx.node_attribute_xy(self.M, "fish"))
-        attrxy_result = [
-            ("one", "one"),
-            ("one", "one"),
-            ("one", "one"),
-            ("one", "one"),
-            ("two", "two"),
-            ("two", "two"),
-        ]
-        assert attrxy == attrxy_result
-
-    def test_node_attribute_xy_selfloop(self):
-        attrxy = sorted(nx.node_attribute_xy(self.S, "fish"))
-        attrxy_result = [("one", "one"), ("two", "two")]
-        assert attrxy == attrxy_result
-
-
-class TestDegreeMixingXY(BaseTestDegreeMixing):
-    def test_node_degree_xy_undirected(self):
-        xy = sorted(nx.node_degree_xy(self.P4))
-        xy_result = sorted([(1, 2), (2, 1), (2, 2), (2, 2), (1, 2), (2, 1)])
-        assert xy == xy_result
-
-    def test_node_degree_xy_undirected_nodes(self):
-        xy = sorted(nx.node_degree_xy(self.P4, nodes=[0, 1, -1]))
-        xy_result = sorted([(1, 2), (2, 1)])
-        assert xy == xy_result
-
-    def test_node_degree_xy_directed(self):
-        xy = sorted(nx.node_degree_xy(self.D))
-        xy_result = sorted([(2, 1), (2, 3), (1, 3), (1, 3)])
-        assert xy == xy_result
-
-    def test_node_degree_xy_multigraph(self):
-        xy = sorted(nx.node_degree_xy(self.M))
-        xy_result = sorted(
-            [(2, 3), (2, 3), (3, 2), (3, 2), (2, 3), (3, 2), (1, 2), (2, 1)]
-        )
-        assert xy == xy_result
-
-    def test_node_degree_xy_selfloop(self):
-        xy = sorted(nx.node_degree_xy(self.S))
-        xy_result = sorted([(2, 2), (2, 2)])
-        assert xy == xy_result
-
-    def test_node_degree_xy_weighted(self):
-        G = nx.Graph()
-        G.add_edge(1, 2, weight=7)
-        G.add_edge(2, 3, weight=10)
-        xy = sorted(nx.node_degree_xy(G, weight="weight"))
-        xy_result = sorted([(7, 17), (17, 10), (17, 7), (10, 17)])
-        assert xy == xy_result

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/tests/test_basic.py

@@ -1,125 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms import bipartite
-
-
-class TestBipartiteBasic:
-    def test_is_bipartite(self):
-        assert bipartite.is_bipartite(nx.path_graph(4))
-        assert bipartite.is_bipartite(nx.DiGraph([(1, 0)]))
-        assert not bipartite.is_bipartite(nx.complete_graph(3))
-
-    def test_bipartite_color(self):
-        G = nx.path_graph(4)
-        c = bipartite.color(G)
-        assert c == {0: 1, 1: 0, 2: 1, 3: 0}
-
-    def test_not_bipartite_color(self):
-        with pytest.raises(nx.NetworkXError):
-            c = bipartite.color(nx.complete_graph(4))
-
-    def test_bipartite_directed(self):
-        G = bipartite.random_graph(10, 10, 0.1, directed=True)
-        assert bipartite.is_bipartite(G)
-
-    def test_bipartite_sets(self):
-        G = nx.path_graph(4)
-        X, Y = bipartite.sets(G)
-        assert X == {0, 2}
-        assert Y == {1, 3}
-
-    def test_bipartite_sets_directed(self):
-        G = nx.path_graph(4)
-        D = G.to_directed()
-        X, Y = bipartite.sets(D)
-        assert X == {0, 2}
-        assert Y == {1, 3}
-
-    def test_bipartite_sets_given_top_nodes(self):
-        G = nx.path_graph(4)
-        top_nodes = [0, 2]
-        X, Y = bipartite.sets(G, top_nodes)
-        assert X == {0, 2}
-        assert Y == {1, 3}
-
-    def test_bipartite_sets_disconnected(self):
-        with pytest.raises(nx.AmbiguousSolution):
-            G = nx.path_graph(4)
-            G.add_edges_from([(5, 6), (6, 7)])
-            X, Y = bipartite.sets(G)
-
-    def test_is_bipartite_node_set(self):
-        G = nx.path_graph(4)
-
-        with pytest.raises(nx.AmbiguousSolution):
-            bipartite.is_bipartite_node_set(G, [1, 1, 2, 3])
-
-        assert bipartite.is_bipartite_node_set(G, [0, 2])
-        assert bipartite.is_bipartite_node_set(G, [1, 3])
-        assert not bipartite.is_bipartite_node_set(G, [1, 2])
-        G.add_edge(10, 20)
-        assert bipartite.is_bipartite_node_set(G, [0, 2, 10])
-        assert bipartite.is_bipartite_node_set(G, [0, 2, 20])
-        assert bipartite.is_bipartite_node_set(G, [1, 3, 10])
-        assert bipartite.is_bipartite_node_set(G, [1, 3, 20])
-
-    def test_bipartite_density(self):
-        G = nx.path_graph(5)
-        X, Y = bipartite.sets(G)
-        density = len(list(G.edges())) / (len(X) * len(Y))
-        assert bipartite.density(G, X) == density
-        D = nx.DiGraph(G.edges())
-        assert bipartite.density(D, X) == density / 2.0
-        assert bipartite.density(nx.Graph(), {}) == 0.0
-
-    def test_bipartite_degrees(self):
-        G = nx.path_graph(5)
-        X = {1, 3}
-        Y = {0, 2, 4}
-        u, d = bipartite.degrees(G, Y)
-        assert dict(u) == {1: 2, 3: 2}
-        assert dict(d) == {0: 1, 2: 2, 4: 1}
-
-    def test_bipartite_weighted_degrees(self):
-        G = nx.path_graph(5)
-        G.add_edge(0, 1, weight=0.1, other=0.2)
-        X = {1, 3}
-        Y = {0, 2, 4}
-        u, d = bipartite.degrees(G, Y, weight="weight")
-        assert dict(u) == {1: 1.1, 3: 2}
-        assert dict(d) == {0: 0.1, 2: 2, 4: 1}
-        u, d = bipartite.degrees(G, Y, weight="other")
-        assert dict(u) == {1: 1.2, 3: 2}
-        assert dict(d) == {0: 0.2, 2: 2, 4: 1}
-
-    def test_biadjacency_matrix_weight(self):
-        pytest.importorskip("scipy")
-        G = nx.path_graph(5)
-        G.add_edge(0, 1, weight=2, other=4)
-        X = [1, 3]
-        Y = [0, 2, 4]
-        M = bipartite.biadjacency_matrix(G, X, weight="weight")
-        assert M[0, 0] == 2
-        M = bipartite.biadjacency_matrix(G, X, weight="other")
-        assert M[0, 0] == 4
-
-    def test_biadjacency_matrix(self):
-        pytest.importorskip("scipy")
-        tops = [2, 5, 10]
-        bots = [5, 10, 15]
-        for i in range(len(tops)):
-            G = bipartite.random_graph(tops[i], bots[i], 0.2)
-            top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
-            M = bipartite.biadjacency_matrix(G, top)
-            assert M.shape[0] == tops[i]
-            assert M.shape[1] == bots[i]
-
-    def test_biadjacency_matrix_order(self):
-        pytest.importorskip("scipy")
-        G = nx.path_graph(5)
-        G.add_edge(0, 1, weight=2)
-        X = [3, 1]
-        Y = [4, 2, 0]
-        M = bipartite.biadjacency_matrix(G, X, Y, weight="weight")
-        assert M[1, 2] == 2

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

@@ -1,192 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms import bipartite
-
-
-class TestBipartiteCentrality:
-    @classmethod
-    def setup_class(cls):
-        cls.P4 = nx.path_graph(4)
-        cls.K3 = nx.complete_bipartite_graph(3, 3)
-        cls.C4 = nx.cycle_graph(4)
-        cls.davis = nx.davis_southern_women_graph()
-        cls.top_nodes = [
-            n for n, d in cls.davis.nodes(data=True) if d["bipartite"] == 0
-        ]
-
-    def test_degree_centrality(self):
-        d = bipartite.degree_centrality(self.P4, [1, 3])
-        answer = {0: 0.5, 1: 1.0, 2: 1.0, 3: 0.5}
-        assert d == answer
-        d = bipartite.degree_centrality(self.K3, [0, 1, 2])
-        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0}
-        assert d == answer
-        d = bipartite.degree_centrality(self.C4, [0, 2])
-        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0}
-        assert d == answer
-
-    def test_betweenness_centrality(self):
-        c = bipartite.betweenness_centrality(self.P4, [1, 3])
-        answer = {0: 0.0, 1: 1.0, 2: 1.0, 3: 0.0}
-        assert c == answer
-        c = bipartite.betweenness_centrality(self.K3, [0, 1, 2])
-        answer = {0: 0.125, 1: 0.125, 2: 0.125, 3: 0.125, 4: 0.125, 5: 0.125}
-        assert c == answer
-        c = bipartite.betweenness_centrality(self.C4, [0, 2])
-        answer = {0: 0.25, 1: 0.25, 2: 0.25, 3: 0.25}
-        assert c == answer
-
-    def test_closeness_centrality(self):
-        c = bipartite.closeness_centrality(self.P4, [1, 3])
-        answer = {0: 2.0 / 3, 1: 1.0, 2: 1.0, 3: 2.0 / 3}
-        assert c == answer
-        c = bipartite.closeness_centrality(self.K3, [0, 1, 2])
-        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0}
-        assert c == answer
-        c = bipartite.closeness_centrality(self.C4, [0, 2])
-        answer = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0}
-        assert c == answer
-        G = nx.Graph()
-        G.add_node(0)
-        G.add_node(1)
-        c = bipartite.closeness_centrality(G, [0])
-        assert c == {0: 0.0, 1: 0.0}
-        c = bipartite.closeness_centrality(G, [1])
-        assert c == {0: 0.0, 1: 0.0}
-
-    def test_bipartite_closeness_centrality_unconnected(self):
-        G = nx.complete_bipartite_graph(3, 3)
-        G.add_edge(6, 7)
-        c = bipartite.closeness_centrality(G, [0, 2, 4, 6], normalized=False)
-        answer = {
-            0: 10.0 / 7,
-            2: 10.0 / 7,
-            4: 10.0 / 7,
-            6: 10.0,
-            1: 10.0 / 7,
-            3: 10.0 / 7,
-            5: 10.0 / 7,
-            7: 10.0,
-        }
-        assert c == answer
-
-    def test_davis_degree_centrality(self):
-        G = self.davis
-        deg = bipartite.degree_centrality(G, self.top_nodes)
-        answer = {
-            "E8": 0.78,
-            "E9": 0.67,
-            "E7": 0.56,
-            "Nora Fayette": 0.57,
-            "Evelyn Jefferson": 0.57,
-            "Theresa Anderson": 0.57,
-            "E6": 0.44,
-            "Sylvia Avondale": 0.50,
-            "Laura Mandeville": 0.50,
-            "Brenda Rogers": 0.50,
-            "Katherina Rogers": 0.43,
-            "E5": 0.44,
-            "Helen Lloyd": 0.36,
-            "E3": 0.33,
-            "Ruth DeSand": 0.29,
-            "Verne Sanderson": 0.29,
-            "E12": 0.33,
-            "Myra Liddel": 0.29,
-            "E11": 0.22,
-            "Eleanor Nye": 0.29,
-            "Frances Anderson": 0.29,
-            "Pearl Oglethorpe": 0.21,
-            "E4": 0.22,
-            "Charlotte McDowd": 0.29,
-            "E10": 0.28,
-            "Olivia Carleton": 0.14,
-            "Flora Price": 0.14,
-            "E2": 0.17,
-            "E1": 0.17,
-            "Dorothy Murchison": 0.14,
-            "E13": 0.17,
-            "E14": 0.17,
-        }
-        for node, value in answer.items():
-            assert value == pytest.approx(deg[node], abs=1e-2)
-
-    def test_davis_betweenness_centrality(self):
-        G = self.davis
-        bet = bipartite.betweenness_centrality(G, self.top_nodes)
-        answer = {
-            "E8": 0.24,
-            "E9": 0.23,
-            "E7": 0.13,
-            "Nora Fayette": 0.11,
-            "Evelyn Jefferson": 0.10,
-            "Theresa Anderson": 0.09,
-            "E6": 0.07,
-            "Sylvia Avondale": 0.07,
-            "Laura Mandeville": 0.05,
-            "Brenda Rogers": 0.05,
-            "Katherina Rogers": 0.05,
-            "E5": 0.04,
-            "Helen Lloyd": 0.04,
-            "E3": 0.02,
-            "Ruth DeSand": 0.02,
-            "Verne Sanderson": 0.02,
-            "E12": 0.02,
-            "Myra Liddel": 0.02,
-            "E11": 0.02,
-            "Eleanor Nye": 0.01,
-            "Frances Anderson": 0.01,
-            "Pearl Oglethorpe": 0.01,
-            "E4": 0.01,
-            "Charlotte McDowd": 0.01,
-            "E10": 0.01,
-            "Olivia Carleton": 0.01,
-            "Flora Price": 0.01,
-            "E2": 0.00,
-            "E1": 0.00,
-            "Dorothy Murchison": 0.00,
-            "E13": 0.00,
-            "E14": 0.00,
-        }
-        for node, value in answer.items():
-            assert value == pytest.approx(bet[node], abs=1e-2)
-
-    def test_davis_closeness_centrality(self):
-        G = self.davis
-        clos = bipartite.closeness_centrality(G, self.top_nodes)
-        answer = {
-            "E8": 0.85,
-            "E9": 0.79,
-            "E7": 0.73,
-            "Nora Fayette": 0.80,
-            "Evelyn Jefferson": 0.80,
-            "Theresa Anderson": 0.80,
-            "E6": 0.69,
-            "Sylvia Avondale": 0.77,
-            "Laura Mandeville": 0.73,
-            "Brenda Rogers": 0.73,
-            "Katherina Rogers": 0.73,
-            "E5": 0.59,
-            "Helen Lloyd": 0.73,
-            "E3": 0.56,
-            "Ruth DeSand": 0.71,
-            "Verne Sanderson": 0.71,
-            "E12": 0.56,
-            "Myra Liddel": 0.69,
-            "E11": 0.54,
-            "Eleanor Nye": 0.67,
-            "Frances Anderson": 0.67,
-            "Pearl Oglethorpe": 0.67,
-            "E4": 0.54,
-            "Charlotte McDowd": 0.60,
-            "E10": 0.55,
-            "Olivia Carleton": 0.59,
-            "Flora Price": 0.59,
-            "E2": 0.52,
-            "E1": 0.52,
-            "Dorothy Murchison": 0.65,
-            "E13": 0.52,
-            "E14": 0.52,
-        }
-        for node, value in answer.items():
-            assert value == pytest.approx(clos[node], abs=1e-2)