Pagerank followup (networkx#4399)

Author: jarrodmillman

networkx/algorithms/link_analysis/pagerank_alg.py

@@ -236,7 +236,7 @@ def google_matrix(
     if nodelist is None:
         nodelist = list(G)
 
-    M = nx.to_numpy_matrix(G, nodelist=nodelist, weight=weight)
+    M = np.asmatrix(nx.to_numpy_array(G, nodelist=nodelist, weight=weight))
     N = len(G)
     if N == 0:
         return M
@@ -336,7 +336,7 @@ def pagerank_numpy(G, alpha=0.85, personalization=None, weight="weight", danglin
        The PageRank citation ranking: Bringing order to the Web. 1999
        http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
     """
-    msg = "networkx.pagerank_numpy will be deprecated in NetworkX 3.0, use networkx.pagerank instead."
+    msg = "networkx.pagerank_numpy is deprecated and will be removed in NetworkX 3.0, use networkx.pagerank instead."
     warn(msg, DeprecationWarning, stacklevel=2)
     import numpy as np
 
@@ -446,7 +446,7 @@ def pagerank_scipy(
        The PageRank citation ranking: Bringing order to the Web. 1999
        http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
     """
-    msg = "networkx.pagerank_scipy will be deprecated in NetworkX 3.0, use networkx.pagerank instead."
+    msg = "networkx.pagerank_scipy is deprecated and will be removed in NetworkX 3.0, use networkx.pagerank instead."
     warn(msg, DeprecationWarning, stacklevel=2)
     import numpy as np
     import scipy.sparse

networkx/algorithms/link_analysis/tests/test_pagerank.py

@@ -1,6 +1,6 @@
 import random
 
-import networkx
+import networkx as nx
 import pytest
 
 numpy = pytest.importorskip("numpy")
@@ -17,7 +17,7 @@
 class TestPageRank:
     @classmethod
     def setup_class(cls):
-        G = networkx.DiGraph()
+        G = nx.DiGraph()
         edges = [
             (1, 2),
             (1, 3),
@@ -55,7 +55,7 @@ def setup_class(cls):
             )
         )
 
-    @pytest.mark.parametrize("alg", (networkx.pagerank, _pagerank_python))
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
     def test_pagerank(self, alg):
         G = self.G
         p = alg(G, alpha=0.9, tol=1.0e-08)
@@ -67,30 +67,28 @@ def test_pagerank(self, alg):
         for n in G:
             assert almost_equal(p[n], G.pagerank[n], places=4)
 
-    @pytest.mark.parametrize("alg", (networkx.pagerank, _pagerank_python))
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
     def test_pagerank_max_iter(self, alg):
-        with pytest.raises(networkx.PowerIterationFailedConvergence):
+        with pytest.raises(nx.PowerIterationFailedConvergence):
             alg(self.G, max_iter=0)
 
     def test_numpy_pagerank(self):
         G = self.G
-        p = networkx.pagerank_numpy(G, alpha=0.9)
+        p = nx.pagerank_numpy(G, alpha=0.9)
         for n in G:
             assert almost_equal(p[n], G.pagerank[n], places=4)
 
     def test_google_matrix(self):
         G = self.G
-        M = networkx.google_matrix(G, alpha=0.9, nodelist=sorted(G))
+        M = nx.google_matrix(G, alpha=0.9, nodelist=sorted(G))
         e, ev = numpy.linalg.eig(M.T)
         p = numpy.array(ev[:, 0] / ev[:, 0].sum())[:, 0]
         for (a, b) in zip(p, self.G.pagerank.values()):
             assert almost_equal(a, b)
 
-    @pytest.mark.parametrize(
-        "alg", (networkx.pagerank, _pagerank_python, networkx.pagerank_numpy)
-    )
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.pagerank_numpy))
     def test_personalization(self, alg):
-        G = networkx.complete_graph(4)
+        G = nx.complete_graph(4)
         personalize = {0: 1, 1: 1, 2: 4, 3: 4}
         answer = {
             0: 0.23246732615667579,
@@ -102,17 +100,15 @@ def test_personalization(self, alg):
         for n in G:
             assert almost_equal(p[n], answer[n], places=4)
 
-    @pytest.mark.parametrize(
-        "alg", (networkx.pagerank, _pagerank_python, networkx.google_matrix)
-    )
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.google_matrix))
     def test_zero_personalization_vector(self, alg):
-        G = networkx.complete_graph(4)
+        G = nx.complete_graph(4)
         personalize = {0: 0, 1: 0, 2: 0, 3: 0}
         pytest.raises(ZeroDivisionError, alg, G, personalization=personalize)
 
-    @pytest.mark.parametrize("alg", (networkx.pagerank, _pagerank_python))
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
     def test_one_nonzero_personalization_value(self, alg):
-        G = networkx.complete_graph(4)
+        G = nx.complete_graph(4)
         personalize = {0: 0, 1: 0, 2: 0, 3: 1}
         answer = {
             0: 0.22077931820379187,
@@ -124,9 +120,9 @@ def test_one_nonzero_personalization_value(self, alg):
         for n in G:
             assert almost_equal(p[n], answer[n], places=4)
 
-    @pytest.mark.parametrize("alg", (networkx.pagerank, _pagerank_python))
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
     def test_incomplete_personalization(self, alg):
-        G = networkx.complete_graph(4)
+        G = nx.complete_graph(4)
         personalize = {3: 1}
         answer = {
             0: 0.22077931820379187,
@@ -146,8 +142,8 @@ def test_dangling_matrix(self):
         G = self.G
         dangling = self.dangling_edges
         dangling_sum = float(sum(dangling.values()))
-        M1 = networkx.google_matrix(G, personalization=dangling)
-        M2 = networkx.google_matrix(G, personalization=dangling, dangling=dangling)
+        M1 = nx.google_matrix(G, personalization=dangling)
+        M2 = nx.google_matrix(G, personalization=dangling, dangling=dangling)
         for i in range(len(G)):
             for j in range(len(G)):
                 if i == self.dangling_node_index and (j + 1) in dangling:
@@ -157,24 +153,22 @@ def test_dangling_matrix(self):
                 else:
                     assert almost_equal(M2[i, j], M1[i, j], places=4)
 
-    @pytest.mark.parametrize(
-        "alg", (networkx.pagerank, _pagerank_python, networkx.pagerank_numpy)
-    )
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.pagerank_numpy))
     def test_dangling_pagerank(self, alg):
         pr = alg(self.G, dangling=self.dangling_edges)
         for n in self.G:
             assert almost_equal(pr[n], self.G.dangling_pagerank[n], places=4)
 
     def test_empty(self):
-        G = networkx.Graph()
-        assert networkx.pagerank(G) == {}
+        G = nx.Graph()
+        assert nx.pagerank(G) == {}
         assert _pagerank_python(G) == {}
-        assert networkx.pagerank_numpy(G) == {}
-        assert networkx.google_matrix(G).shape == (0, 0)
+        assert nx.pagerank_numpy(G) == {}
+        assert nx.google_matrix(G).shape == (0, 0)
 
-    @pytest.mark.parametrize("alg", (networkx.pagerank, _pagerank_python))
+    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
     def test_multigraph(self, alg):
-        G = networkx.MultiGraph()
+        G = nx.MultiGraph()
         G.add_edges_from([(1, 2), (1, 2), (1, 2), (2, 3), (2, 3), ("3", 3), ("3", 3)])
         answer = {
             1: 0.21066048614468322,
@@ -190,42 +184,40 @@ def test_multigraph(self, alg):
 class TestPageRankScipy(TestPageRank):
     def test_scipy_pagerank(self):
         G = self.G
-        p = networkx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08)
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08)
         for n in G:
             assert almost_equal(p[n], G.pagerank[n], places=4)
         personalize = {n: random.random() for n in G}
-        p = networkx.pagerank_scipy(
-            G, alpha=0.9, tol=1.0e-08, personalization=personalize
-        )
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08, personalization=personalize)
 
         nstart = {n: random.random() for n in G}
-        p = networkx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
+        p = nx.pagerank_scipy(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
         for n in G:
             assert almost_equal(p[n], G.pagerank[n], places=4)
 
     def test_scipy_pagerank_max_iter(self):
-        with pytest.raises(networkx.PowerIterationFailedConvergence):
-            networkx.pagerank_scipy(self.G, max_iter=0)
+        with pytest.raises(nx.PowerIterationFailedConvergence):
+            nx.pagerank_scipy(self.G, max_iter=0)
 
     def test_dangling_scipy_pagerank(self):
-        pr = networkx.pagerank_scipy(self.G, dangling=self.dangling_edges)
+        pr = nx.pagerank_scipy(self.G, dangling=self.dangling_edges)
         for n in self.G:
             assert almost_equal(pr[n], self.G.dangling_pagerank[n], places=4)
 
     def test_empty_scipy(self):
-        G = networkx.Graph()
-        assert networkx.pagerank_scipy(G) == {}
+        G = nx.Graph()
+        assert nx.pagerank_scipy(G) == {}
 
 
 @pytest.mark.parametrize(
     "pagerank_alg",
-    (networkx.pagerank_numpy, networkx.pagerank_scipy),
+    (nx.pagerank_numpy, nx.pagerank_scipy),
 )
 def test_deprecation_warnings(pagerank_alg):
     """Make sure deprecation warnings are raised.
 
     To be removed when deprecations expire.
     """
-    G = networkx.DiGraph(networkx.path_graph(4))
+    G = nx.DiGraph(nx.path_graph(4))
     with pytest.warns(DeprecationWarning):
         pr = pagerank_alg(G, alpha=0.9)