okstra 0.107.2 → 0.109.0

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

@@ -0,0 +1,407 @@
+import numbers
+
+import pytest
+
+import networkx as nx
+
+from ..generators import (
+    alternating_havel_hakimi_graph,
+    complete_bipartite_graph,
+    configuration_model,
+    gnmk_random_graph,
+    havel_hakimi_graph,
+    preferential_attachment_graph,
+    random_graph,
+    reverse_havel_hakimi_graph,
+)
+
+"""
+Generators - Bipartite
+----------------------
+"""
+
+
+class TestGeneratorsBipartite:
+    def test_complete_bipartite_graph(self):
+        G = complete_bipartite_graph(0, 0)
+        assert nx.is_isomorphic(G, nx.null_graph())
+
+        for i in [1, 5]:
+            G = complete_bipartite_graph(i, 0)
+            assert nx.is_isomorphic(G, nx.empty_graph(i))
+            G = complete_bipartite_graph(0, i)
+            assert nx.is_isomorphic(G, nx.empty_graph(i))
+
+        G = complete_bipartite_graph(2, 2)
+        assert nx.is_isomorphic(G, nx.cycle_graph(4))
+
+        G = complete_bipartite_graph(1, 5)
+        assert nx.is_isomorphic(G, nx.star_graph(5))
+
+        G = complete_bipartite_graph(5, 1)
+        assert nx.is_isomorphic(G, nx.star_graph(5))
+
+        # complete_bipartite_graph(m1,m2) is a connected graph with
+        # m1+m2 nodes and  m1*m2 edges
+        for m1, m2 in [(5, 11), (7, 3)]:
+            G = complete_bipartite_graph(m1, m2)
+            assert nx.number_of_nodes(G) == m1 + m2
+            assert nx.number_of_edges(G) == m1 * m2
+
+        with pytest.raises(nx.NetworkXError):
+            complete_bipartite_graph(7, 3, create_using=nx.DiGraph)
+        with pytest.raises(nx.NetworkXError):
+            complete_bipartite_graph(7, 3, create_using=nx.MultiDiGraph)
+
+        mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
+        assert mG.is_multigraph()
+        assert sorted(mG.edges()) == sorted(G.edges())
+
+        mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
+        assert mG.is_multigraph()
+        assert sorted(mG.edges()) == sorted(G.edges())
+
+        mG = complete_bipartite_graph(7, 3)  # default to Graph
+        assert sorted(mG.edges()) == sorted(G.edges())
+        assert not mG.is_multigraph()
+        assert not mG.is_directed()
+
+        # specify nodes rather than number of nodes
+        for n1, n2 in [([1, 2], "ab"), (3, 2), (3, "ab"), ("ab", 3)]:
+            G = complete_bipartite_graph(n1, n2)
+            if isinstance(n1, numbers.Integral):
+                if isinstance(n2, numbers.Integral):
+                    n2 = range(n1, n1 + n2)
+                n1 = range(n1)
+            elif isinstance(n2, numbers.Integral):
+                n2 = range(n2)
+            edges = {(u, v) for u in n1 for v in n2}
+            assert edges == set(G.edges)
+            assert G.size() == len(edges)
+
+        # raise when node sets are not distinct
+        for n1, n2 in [([1, 2], 3), (3, [1, 2]), ("abc", "bcd")]:
+            pytest.raises(nx.NetworkXError, complete_bipartite_graph, n1, n2)
+
+    def test_configuration_model(self):
+        aseq = []
+        bseq = []
+        G = configuration_model(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = configuration_model(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, configuration_model, aseq, bseq)
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = configuration_model(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = configuration_model(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = configuration_model(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph()
+        )
+        pytest.raises(
+            nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            configuration_model,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 4
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_reverse_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, reverse_havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = reverse_havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            reverse_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_alternating_havel_hakimi_graph(self):
+        aseq = []
+        bseq = []
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 0
+
+        aseq = [0, 0]
+        bseq = [0, 0]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert len(G) == 4
+        assert G.number_of_edges() == 0
+
+        aseq = [3, 3, 3, 3]
+        bseq = [2, 2, 2, 2, 2]
+        pytest.raises(nx.NetworkXError, alternating_havel_hakimi_graph, aseq, bseq)
+
+        bseq = [2, 2, 2, 2, 2, 2]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 2, 2, 2]
+        bseq = [3, 3, 3, 3]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
+
+        aseq = [2, 2, 2, 1, 1, 1]
+        bseq = [3, 3, 3]
+        G = alternating_havel_hakimi_graph(aseq, bseq)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+        assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
+
+        GU = nx.projected_graph(nx.Graph(G), range(len(aseq)))
+        assert GU.number_of_nodes() == 6
+
+        GD = nx.projected_graph(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
+        assert GD.number_of_nodes() == 3
+
+        G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.DiGraph,
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            alternating_havel_hakimi_graph,
+            aseq,
+            bseq,
+            create_using=nx.MultiDiGraph,
+        )
+
+    def test_preferential_attachment(self):
+        aseq = [3, 2, 1, 1]
+        G = preferential_attachment_graph(aseq, 0.5)
+        assert G.is_multigraph()
+        assert not G.is_directed()
+
+        G = preferential_attachment_graph(aseq, 0.5, create_using=nx.Graph)
+        assert not G.is_multigraph()
+        assert not G.is_directed()
+
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+        pytest.raises(
+            nx.NetworkXError,
+            preferential_attachment_graph,
+            aseq,
+            0.5,
+            create_using=nx.DiGraph(),
+        )
+
+    def test_random_graph(self):
+        n = 10
+        m = 20
+        G = random_graph(n, m, 0.9)
+        assert len(G) == 30
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+
+    def test_random_digraph(self):
+        n = 10
+        m = 20
+        G = random_graph(n, m, 0.9, directed=True)
+        assert len(G) == 30
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+
+    def test_gnmk_random_graph(self):
+        n = 10
+        m = 20
+        edges = 100
+        # set seed because sometimes it is not connected
+        # which raises an error in bipartite.sets(G) below.
+        G = gnmk_random_graph(n, m, edges, seed=1234)
+        assert len(G) == n + m
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+        assert edges == len(list(G.edges()))
+
+    def test_gnmk_random_graph_complete(self):
+        n = 10
+        m = 20
+        edges = 200
+        G = gnmk_random_graph(n, m, edges)
+        assert len(G) == n + m
+        assert nx.is_bipartite(G)
+        X, Y = nx.algorithms.bipartite.sets(G)
+        assert set(range(n)) == X
+        assert set(range(n, n + m)) == Y
+        assert edges == len(list(G.edges()))
+
+    @pytest.mark.parametrize("n", (4, range(4), {0, 1, 2, 3}))
+    @pytest.mark.parametrize("m", (range(4, 7), {4, 5, 6}))
+    def test_complete_bipartite_graph_str(self, n, m):
+        """Ensure G.name is consistent for all inputs accepted by nodes_or_number.
+        See gh-7396"""
+        G = nx.complete_bipartite_graph(n, m)
+        ans = "Graph named 'complete_bipartite_graph(4, 3)' with 7 nodes and 12 edges"
+        assert str(G) == ans

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

@@ -0,0 +1,218 @@
+import itertools
+
+import pytest
+
+import networkx as nx
+from networkx.algorithms import bipartite
+
+pytest.importorskip("scipy")
+
+
+class TestBipartiteLinkAnalysis:
+    @classmethod
+    def setup_class(cls):
+        cls.davis_southern_women_graph = nx.davis_southern_women_graph()
+        cls.women_bipartite_set = {
+            node
+            for node, bipartite in cls.davis_southern_women_graph.nodes(
+                data="bipartite"
+            )
+            if bipartite == 0
+        }
+        cls.gnmk_random_graph = nx.bipartite.generators.gnmk_random_graph(
+            5 * 10**2, 10**2, 5 * 10**2, seed=27
+        )
+        cls.gnmk_random_graph_top_nodes = {
+            node
+            for node, bipartite in cls.gnmk_random_graph.nodes(data="bipartite")
+            if bipartite == 0
+        }
+
+    def test_collaborative_filtering_birank(self):
+        elist = [
+            ("u1", "p1", 5),
+            ("u2", "p1", 5),
+            ("u2", "p2", 4),
+            ("u3", "p1", 3),
+            ("u3", "p3", 2),
+        ]
+        item_recommendation_graph = nx.DiGraph()
+        item_recommendation_graph.add_weighted_edges_from(elist, weight="rating")
+        product_nodes = ("p1", "p2", "p3")
+        u1_query = {
+            product: rating
+            for _, product, rating in item_recommendation_graph.edges(
+                nbunch="u1", data="rating"
+            )
+        }
+        u1_birank_results = bipartite.birank(
+            item_recommendation_graph,
+            product_nodes,
+            alpha=0.8,
+            beta=1.0,
+            top_personalization=u1_query,
+            weight="rating",
+        )
+
+        assert u1_birank_results["p2"] > u1_birank_results["p3"]
+
+        u1_birank_results_unweighted = bipartite.birank(
+            item_recommendation_graph,
+            product_nodes,
+            alpha=0.8,
+            beta=1.0,
+            top_personalization=u1_query,
+            weight=None,
+        )
+
+        assert u1_birank_results_unweighted["p2"] == pytest.approx(
+            u1_birank_results_unweighted["p3"], rel=2e-6
+        )
+
+    def test_davis_birank(self):
+        scores = bipartite.birank(
+            self.davis_southern_women_graph, self.women_bipartite_set
+        )
+        answer = {
+            "Laura Mandeville": 0.07,
+            "Olivia Carleton": 0.04,
+            "Frances Anderson": 0.05,
+            "Pearl Oglethorpe": 0.04,
+            "Katherina Rogers": 0.06,
+            "Flora Price": 0.04,
+            "Dorothy Murchison": 0.04,
+            "Helen Lloyd": 0.06,
+            "Theresa Anderson": 0.07,
+            "Eleanor Nye": 0.05,
+            "Evelyn Jefferson": 0.07,
+            "Sylvia Avondale": 0.07,
+            "Charlotte McDowd": 0.05,
+            "Verne Sanderson": 0.05,
+            "Myra Liddel": 0.05,
+            "Brenda Rogers": 0.07,
+            "Ruth DeSand": 0.05,
+            "Nora Fayette": 0.07,
+            "E8": 0.11,
+            "E7": 0.09,
+            "E10": 0.07,
+            "E9": 0.1,
+            "E13": 0.05,
+            "E3": 0.07,
+            "E12": 0.07,
+            "E11": 0.06,
+            "E2": 0.05,
+            "E5": 0.08,
+            "E6": 0.08,
+            "E14": 0.05,
+            "E4": 0.06,
+            "E1": 0.05,
+        }
+
+        for node, value in answer.items():
+            assert scores[node] == pytest.approx(value, abs=1e-2)
+
+    def test_davis_birank_with_personalization(self):
+        women_personalization = {"Laura Mandeville": 1}
+        scores = bipartite.birank(
+            self.davis_southern_women_graph,
+            self.women_bipartite_set,
+            top_personalization=women_personalization,
+        )
+        answer = {
+            "Laura Mandeville": 0.29,
+            "Olivia Carleton": 0.02,
+            "Frances Anderson": 0.06,
+            "Pearl Oglethorpe": 0.04,
+            "Katherina Rogers": 0.04,
+            "Flora Price": 0.02,
+            "Dorothy Murchison": 0.03,
+            "Helen Lloyd": 0.04,
+            "Theresa Anderson": 0.08,
+            "Eleanor Nye": 0.05,
+            "Evelyn Jefferson": 0.09,
+            "Sylvia Avondale": 0.05,
+            "Charlotte McDowd": 0.06,
+            "Verne Sanderson": 0.04,
+            "Myra Liddel": 0.03,
+            "Brenda Rogers": 0.08,
+            "Ruth DeSand": 0.05,
+            "Nora Fayette": 0.05,
+            "E8": 0.11,
+            "E7": 0.1,
+            "E10": 0.04,
+            "E9": 0.07,
+            "E13": 0.03,
+            "E3": 0.11,
+            "E12": 0.04,
+            "E11": 0.03,
+            "E2": 0.1,
+            "E5": 0.11,
+            "E6": 0.1,
+            "E14": 0.03,
+            "E4": 0.06,
+            "E1": 0.1,
+        }
+
+        for node, value in answer.items():
+            assert scores[node] == pytest.approx(value, abs=1e-2)
+
+    def test_birank_empty_bipartite_set(self):
+        G = nx.Graph()
+        all_nodes = [1, 2, 3]
+        G.add_nodes_from(all_nodes)
+
+        # Test with empty bipartite set
+        with pytest.raises(nx.NetworkXAlgorithmError):
+            bipartite.birank(G, all_nodes)
+
+    @pytest.mark.parametrize(
+        "damping_factor,value", itertools.product(["alpha", "beta"], [-0.1, 1.1])
+    )
+    def test_birank_invalid_alpha_beta(self, damping_factor, value):
+        kwargs = {damping_factor: value}
+        with pytest.raises(nx.NetworkXAlgorithmError):
+            bipartite.birank(
+                self.davis_southern_women_graph, self.women_bipartite_set, **kwargs
+            )
+
+    def test_birank_power_iteration_failed_convergence(self):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            bipartite.birank(
+                self.davis_southern_women_graph, self.women_bipartite_set, max_iter=1
+            )
+
+    @pytest.mark.parametrize(
+        "personalization,alpha,beta",
+        itertools.product(
+            [
+                # Concentrated case
+                lambda x: 1000 if x == 0 else 0,
+                # Uniform case
+                lambda x: 5,
+                # Zero case
+                lambda x: 0,
+            ],
+            [i / 2 for i in range(3)],
+            [i / 2 for i in range(3)],
+        ),
+    )
+    def test_gnmk_convergence_birank(self, personalization, alpha, beta):
+        top_personalization_dict = {
+            node: personalization(node) for node in self.gnmk_random_graph_top_nodes
+        }
+        bipartite.birank(
+            self.gnmk_random_graph,
+            self.gnmk_random_graph_top_nodes,
+            top_personalization=top_personalization_dict,
+            alpha=alpha,
+            beta=beta,
+        )
+
+    def test_negative_personalization(self):
+        top_personalization_dict = {0: -1}
+        with pytest.raises(nx.NetworkXAlgorithmError):
+            bipartite.birank(
+                self.gnmk_random_graph,
+                self.gnmk_random_graph_top_nodes,
+                top_personalization=top_personalization_dict,
+            )