MAINT: Fix problems noted by pyflakes in numpy/lib/tests.

1 files changed, 142 insertions, 135 deletions

diff --git a/numpy/lib/tests/test_shape_base.py b/numpy/lib/tests/test_shape_base.py
index d6d01ba99..23f3edfbe 100644
--- a/numpy/lib/tests/test_shape_base.py
+++ b/numpy/lib/tests/test_shape_base.py
@@ -1,214 +1,216 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
-from numpy.lib import *
-from numpy.core import *
-from numpy import matrix, asmatrix
+import numpy as np
+from numpy.lib.shape_base import (
+    apply_along_axis, apply_over_axes, array_split, split, hsplit, dsplit,
+    vsplit, dstack, kron, tile
+    )
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    assert_raises, assert_warns
+    )
 
 
 class TestApplyAlongAxis(TestCase):
     def test_simple(self):
-        a = ones((20, 10), 'd')
+        a = np.ones((20, 10), 'd')
         assert_array_equal(
-            apply_along_axis(len, 0, a), len(a)*ones(shape(a)[1]))
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
 
     def test_simple101(self, level=11):
-        a = ones((10, 101), 'd')
+        a = np.ones((10, 101), 'd')
         assert_array_equal(
-            apply_along_axis(len, 0, a), len(a)*ones(shape(a)[1]))
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
 
     def test_3d(self):
-        a = arange(27).reshape((3, 3, 3))
-        assert_array_equal(apply_along_axis(sum, 0, a),
+        a = np.arange(27).reshape((3, 3, 3))
+        assert_array_equal(apply_along_axis(np.sum, 0, a),
                            [[27, 30, 33], [36, 39, 42], [45, 48, 51]])
 
 
 class TestApplyOverAxes(TestCase):
     def test_simple(self):
-        a = arange(24).reshape(2, 3, 4)
-        aoa_a = apply_over_axes(sum, a, [0, 2])
-        assert_array_equal(aoa_a, array([[[60], [92], [124]]]))
+        a = np.arange(24).reshape(2, 3, 4)
+        aoa_a = apply_over_axes(np.sum, a, [0, 2])
+        assert_array_equal(aoa_a, np.array([[[60], [92], [124]]]))
 
 
 class TestArraySplit(TestCase):
     def test_integer_0_split(self):
-        a = arange(10)
-        try:
-            res = array_split(a, 0)
-            assert_(0)  # it should have thrown a value error
-        except ValueError:
-            pass
+        a = np.arange(10)
+        assert_raises(ValueError, array_split, a, 0)
 
     def test_integer_split(self):
-        a = arange(10)
+        a = np.arange(10)
         res = array_split(a, 1)
-        desired = [arange(10)]
+        desired = [np.arange(10)]
         compare_results(res, desired)
 
         res = array_split(a, 2)
-        desired = [arange(5), arange(5, 10)]
+        desired = [np.arange(5), np.arange(5, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 3)
-        desired = [arange(4), arange(4, 7), arange(7, 10)]
+        desired = [np.arange(4), np.arange(4, 7), np.arange(7, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 4)
-        desired = [arange(3), arange(3, 6), arange(6, 8), arange(8, 10)]
+        desired = [np.arange(3), np.arange(3, 6), np.arange(6, 8),
+                   np.arange(8, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 5)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 8), arange(8, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 6)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 8), arange(8, 9),
-            arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 7)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 7), arange(7, 8),
-            arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 8)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 5), arange(5, 6), arange(6, 7),
-            arange(7, 8), arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 5),
+                   np.arange(5, 6), np.arange(6, 7), np.arange(7, 8),
+                   np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 9)
-        desired = [arange(
-            2), arange(2, 3), arange(3, 4), arange(4, 5), arange(5, 6),
-            arange(6, 7), arange(7, 8), arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 3), np.arange(3, 4),
+                   np.arange(4, 5), np.arange(5, 6), np.arange(6, 7),
+                   np.arange(7, 8), np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 10)
-        desired = [arange(1), arange(1, 2), arange(2, 3), arange(3, 4),
-                   arange(4, 5), arange(5, 6), arange(6, 7), arange(7, 8),
-                   arange(8, 9), arange(9, 10)]
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 11)
-        desired = [arange(1), arange(1, 2), arange(2, 3), arange(3, 4),
-                   arange(4, 5), arange(5, 6), arange(6, 7), arange(7, 8),
-                   arange(8, 9), arange(9, 10), array([])]
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10), np.array([])]
         compare_results(res, desired)
 
     def test_integer_split_2D_rows(self):
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = assert_warns(FutureWarning, array_split, a, 3, axis=0)
 
         # After removing the FutureWarning, the last should be zeros((0, 10))
-        desired = [array([arange(10)]), array([arange(10)]), array([])]
+        desired = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.array([])]
         compare_results(res, desired)
         assert_(a.dtype.type is res[-1].dtype.type)
 
     def test_integer_split_2D_cols(self):
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = array_split(a, 3, axis=-1)
-        desired = [array([arange(4), arange(4)]),
-                   array([arange(4, 7), arange(4, 7)]),
-                   array([arange(7, 10), arange(7, 10)])]
+        desired = [np.array([np.arange(4), np.arange(4)]),
+                   np.array([np.arange(4, 7), np.arange(4, 7)]),
+                   np.array([np.arange(7, 10), np.arange(7, 10)])]
         compare_results(res, desired)
 
     def test_integer_split_2D_default(self):
         """ This will fail if we change default axis
         """
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = assert_warns(FutureWarning, array_split, a, 3)
 
         # After removing the FutureWarning, the last should be zeros((0, 10))
-        desired = [array([arange(10)]), array([arange(10)]), array([])]
+        desired = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.array([])]
         compare_results(res, desired)
         assert_(a.dtype.type is res[-1].dtype.type)
-    #perhaps should check higher dimensions
+        # perhaps should check higher dimensions
 
     def test_index_split_simple(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [1, 5, 7]
         res = array_split(a, indices, axis=-1)
-        desired = [arange(0, 1), arange(1, 5), arange(5, 7), arange(7, 10)]
+        desired = [np.arange(0, 1), np.arange(1, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
         compare_results(res, desired)
 
     def test_index_split_low_bound(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [0, 5, 7]
         res = array_split(a, indices, axis=-1)
-        desired = [array([]), arange(0, 5), arange(5, 7), arange(7, 10)]
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
         compare_results(res, desired)
 
     def test_index_split_high_bound(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [0, 5, 7, 10, 12]
         res = array_split(a, indices, axis=-1)
-        desired = [array([]), arange(0, 5), arange(5, 7), arange(7, 10),
-                   array([]), array([])]
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10), np.array([]), np.array([])]
         compare_results(res, desired)
 
 
 class TestSplit(TestCase):
-    """* This function is essentially the same as array_split,
-         except that it test if splitting will result in an
-         equal split.  Only test for this case.
-    *"""
+    # The split function is essentially the same as array_split,
+    # except that it test if splitting will result in an
+    # equal split.  Only test for this case.
+
     def test_equal_split(self):
-        a = arange(10)
+        a = np.arange(10)
         res = split(a, 2)
-        desired = [arange(5), arange(5, 10)]
+        desired = [np.arange(5), np.arange(5, 10)]
         compare_results(res, desired)
 
     def test_unequal_split(self):
-        a = arange(10)
-        try:
-            res = split(a, 3)
-            assert_(0)  # should raise an error
-        except ValueError:
-            pass
+        a = np.arange(10)
+        assert_raises(ValueError, split, a, 3)
 
 
 class TestDstack(TestCase):
     def test_0D_array(self):
-        a = array(1)
-        b = array(2)
+        a = np.array(1)
+        b = np.array(2)
         res = dstack([a, b])
-        desired = array([[[1, 2]]])
+        desired = np.array([[[1, 2]]])
         assert_array_equal(res, desired)
 
     def test_1D_array(self):
-        a = array([1])
-        b = array([2])
+        a = np.array([1])
+        b = np.array([2])
         res = dstack([a, b])
-        desired = array([[[1, 2]]])
+        desired = np.array([[[1, 2]]])
         assert_array_equal(res, desired)
 
     def test_2D_array(self):
-        a = array([[1], [2]])
-        b = array([[1], [2]])
+        a = np.array([[1], [2]])
+        b = np.array([[1], [2]])
         res = dstack([a, b])
-        desired = array([[[1, 1]], [[2, 2, ]]])
+        desired = np.array([[[1, 1]], [[2, 2, ]]])
         assert_array_equal(res, desired)
 
     def test_2D_array2(self):
-        a = array([1, 2])
-        b = array([1, 2])
+        a = np.array([1, 2])
+        b = np.array([1, 2])
         res = dstack([a, b])
-        desired = array([[[1, 1], [2, 2]]])
+        desired = np.array([[[1, 1], [2, 2]]])
         assert_array_equal(res, desired)
 
-""" array_split has more comprehensive test of splitting.
-    only do simple test on hsplit, vsplit, and dsplit
-"""
-
 
+# array_split has more comprehensive test of splitting.
+# only do simple test on hsplit, vsplit, and dsplit
 class TestHsplit(TestCase):
-    """ only testing for integer splits.
+    """Only testing for integer splits.
+
     """
     def test_0D_array(self):
-        a = array(1)
+        a = np.array(1)
         try:
             hsplit(a, 2)
             assert_(0)
@@ -216,24 +218,25 @@ class TestHsplit(TestCase):
             pass
 
     def test_1D_array(self):
-        a = array([1, 2, 3, 4])
+        a = np.array([1, 2, 3, 4])
         res = hsplit(a, 2)
-        desired = [array([1, 2]), array([3, 4])]
+        desired = [np.array([1, 2]), np.array([3, 4])]
         compare_results(res, desired)
 
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         res = hsplit(a, 2)
-        desired = [array([[1, 2], [1, 2]]), array([[3, 4], [3, 4]])]
+        desired = [np.array([[1, 2], [1, 2]]), np.array([[3, 4], [3, 4]])]
         compare_results(res, desired)
 
 
 class TestVsplit(TestCase):
-    """ only testing for integer splits.
+    """Only testing for integer splits.
+
     """
     def test_1D_array(self):
-        a = array([1, 2, 3, 4])
+        a = np.array([1, 2, 3, 4])
         try:
             vsplit(a, 2)
             assert_(0)
@@ -241,18 +244,18 @@ class TestVsplit(TestCase):
             pass
 
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         res = vsplit(a, 2)
-        desired = [array([[1, 2, 3, 4]]), array([[1, 2, 3, 4]])]
+        desired = [np.array([[1, 2, 3, 4]]), np.array([[1, 2, 3, 4]])]
         compare_results(res, desired)
 
 
 class TestDsplit(TestCase):
-    """ only testing for integer splits.
-    """
+    # Only testing for integer splits.
+
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         try:
             dsplit(a, 2)
@@ -261,54 +264,57 @@ class TestDsplit(TestCase):
             pass
 
     def test_3D_array(self):
-        a = array([[[1, 2, 3, 4],
+        a = np.array([[[1, 2, 3, 4],
                    [1, 2, 3, 4]],
                   [[1, 2, 3, 4],
                    [1, 2, 3, 4]]])
         res = dsplit(a, 2)
-        desired = [array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
-                   array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
+        desired = [np.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
+                   np.array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
         compare_results(res, desired)
 
 
 class TestSqueeze(TestCase):
     def test_basic(self):
+        from numpy.random import rand
+
         a = rand(20, 10, 10, 1, 1)
         b = rand(20, 1, 10, 1, 20)
         c = rand(1, 1, 20, 10)
-        assert_array_equal(squeeze(a), reshape(a, (20, 10, 10)))
-        assert_array_equal(squeeze(b), reshape(b, (20, 10, 20)))
-        assert_array_equal(squeeze(c), reshape(c, (20, 10)))
+        assert_array_equal(np.squeeze(a), np.reshape(a, (20, 10, 10)))
+        assert_array_equal(np.squeeze(b), np.reshape(b, (20, 10, 20)))
+        assert_array_equal(np.squeeze(c), np.reshape(c, (20, 10)))
 
         # Squeezing to 0-dim should still give an ndarray
         a = [[[1.5]]]
-        res = squeeze(a)
+        res = np.squeeze(a)
         assert_equal(res, 1.5)
         assert_equal(res.ndim, 0)
-        assert_equal(type(res), ndarray)
+        assert_equal(type(res), np.ndarray)
 
 
 class TestKron(TestCase):
     def test_return_type(self):
-        a = ones([2, 2])
-        m = asmatrix(a)
-        assert_equal(type(kron(a, a)), ndarray)
-        assert_equal(type(kron(m, m)), matrix)
-        assert_equal(type(kron(a, m)), matrix)
-        assert_equal(type(kron(m, a)), matrix)
-
-        class myarray(ndarray):
+        a = np.ones([2, 2])
+        m = np.asmatrix(a)
+        assert_equal(type(kron(a, a)), np.ndarray)
+        assert_equal(type(kron(m, m)), np.matrix)
+        assert_equal(type(kron(a, m)), np.matrix)
+        assert_equal(type(kron(m, a)), np.matrix)
+
+        class myarray(np.ndarray):
             __array_priority__ = 0.0
+
         ma = myarray(a.shape, a.dtype, a.data)
-        assert_equal(type(kron(a, a)), ndarray)
+        assert_equal(type(kron(a, a)), np.ndarray)
         assert_equal(type(kron(ma, ma)), myarray)
-        assert_equal(type(kron(a, ma)), ndarray)
+        assert_equal(type(kron(a, ma)), np.ndarray)
         assert_equal(type(kron(ma, a)), myarray)
 
 
 class TestTile(TestCase):
     def test_basic(self):
-        a = array([0, 1, 2])
+        a = np.array([0, 1, 2])
         b = [[1, 2], [3, 4]]
         assert_equal(tile(a, 2), [0, 1, 2, 0, 1, 2])
         assert_equal(tile(a, (2, 2)), [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]])
@@ -319,18 +325,19 @@ class TestTile(TestCase):
                                        [1, 2, 1, 2], [3, 4, 3, 4]])
 
     def test_empty(self):
-        a = array([[[]]])
+        a = np.array([[[]]])
         d = tile(a, (3, 2, 5)).shape
         assert_equal(d, (3, 2, 0))
 
     def test_kroncompare(self):
-        import numpy.random as nr
+        from numpy.random import randint
+
         reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
         shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
         for s in shape:
-            b = nr.randint(0, 10, size=s)
+            b = randint(0, 10, size=s)
             for r in reps:
-                a = ones(r, b.dtype)
+                a = np.ones(r, b.dtype)
                 large = tile(b, r)
                 klarge = kron(a, b)
                 assert_equal(large, klarge)
@@ -338,17 +345,17 @@ class TestTile(TestCase):
 
 class TestMayShareMemory(TestCase):
     def test_basic(self):
-        d = ones((50, 60))
-        d2 = ones((30, 60, 6))
-        self.assertTrue(may_share_memory(d, d))
-        self.assertTrue(may_share_memory(d, d[::-1]))
-        self.assertTrue(may_share_memory(d, d[::2]))
-        self.assertTrue(may_share_memory(d, d[1:, ::-1]))
-
-        self.assertFalse(may_share_memory(d[::-1], d2))
-        self.assertFalse(may_share_memory(d[::2], d2))
-        self.assertFalse(may_share_memory(d[1:, ::-1], d2))
-        self.assertTrue(may_share_memory(d2[1:, ::-1], d2))
+        d = np.ones((50, 60))
+        d2 = np.ones((30, 60, 6))
+        self.assertTrue(np.may_share_memory(d, d))
+        self.assertTrue(np.may_share_memory(d, d[::-1]))
+        self.assertTrue(np.may_share_memory(d, d[::2]))
+        self.assertTrue(np.may_share_memory(d, d[1:, ::-1]))
+
+        self.assertFalse(np.may_share_memory(d[::-1], d2))
+        self.assertFalse(np.may_share_memory(d[::2], d2))
+        self.assertFalse(np.may_share_memory(d[1:, ::-1], d2))
+        self.assertTrue(np.may_share_memory(d2[1:, ::-1], d2))
 
 
 # Utility