STY: Clean up code

Pep8 fixes
Remove unused imports
Fix name error

5 files changed, 89 insertions, 67 deletions

diff --git a/numpy/random/tests/test_direct.py b/numpy/random/tests/test_direct.py
index 794a895b8..4ab521d1b 100644
--- a/numpy/random/tests/test_direct.py
+++ b/numpy/random/tests/test_direct.py
@@ -1,14 +1,13 @@
 import os
-import sys
 from os.path import join
 
 import numpy as np
 from numpy.testing import (assert_equal, assert_allclose, assert_array_equal,
-                           assert_raises, assert_warns)
+                           assert_raises)
 import pytest
 
-from numpy.random import (Generator, MT19937, DSFMT, ThreeFry,
-    PCG32, PCG64, Philox, Xoshiro256, Xoshiro512, RandomState)
+from numpy.random import (Generator, MT19937, DSFMT, ThreeFry, PCG32, PCG64,
+                          Philox, Xoshiro256, Xoshiro512, RandomState)
 from numpy.random.common import interface
 
 try:
@@ -25,9 +24,6 @@ try:
 except ImportError:
     MISSING_CTYPES = False
 
-if (sys.version_info > (3, 0)):
-    long = int
-
 pwd = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -102,7 +98,7 @@ def gauss_from_uint(x, n, bits):
         doubles = uniform_from_uint64(x)
     elif bits == 32:
         doubles = uniform_from_uint32(x)
-    elif bits == 'dsfmt':
+    else:  # bits == 'dsfmt'
         doubles = uniform_from_dsfmt(x)
     gauss = []
     loc = 0
@@ -140,10 +136,10 @@ class Base(object):
         with open(filename) as csv:
             seed = csv.readline()
             seed = seed.split(',')
-            seed = [long(s.strip(), 0) for s in seed[1:]]
+            seed = [int(s.strip(), 0) for s in seed[1:]]
             data = []
             for line in csv:
-                data.append(long(line.split(',')[-1].strip(), 0))
+                data.append(int(line.split(',')[-1].strip(), 0))
             return {'seed': seed, 'data': np.array(data, dtype=cls.dtype)}
 
     def test_raw(self):
@@ -213,9 +209,12 @@ class Base(object):
     def test_seed_float_array(self):
         # GH #82
         rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, np.array([-np.pi]))
-        assert_raises(ValueError, rs.bit_generator.seed, np.array([np.pi, -np.pi]))
+        assert_raises(self.seed_error_type, rs.bit_generator.seed,
+                      np.array([np.pi]))
+        assert_raises(self.seed_error_type, rs.bit_generator.seed,
+                      np.array([-np.pi]))
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      np.array([np.pi, -np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([0, np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, [np.pi])
         assert_raises(TypeError, rs.bit_generator.seed, [0, np.pi])
@@ -223,13 +222,15 @@ class Base(object):
     def test_seed_out_of_range(self):
         # GH #82
         rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(ValueError, rs.bit_generator.seed, 2 ** (2 * self.bits + 1))
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      2 ** (2 * self.bits + 1))
         assert_raises(ValueError, rs.bit_generator.seed, -1)
 
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(ValueError, rs.bit_generator.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      [2 ** (2 * self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
 
     def test_repr(self):
@@ -248,8 +249,8 @@ class Base(object):
 
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
-        brng_pkl = pickle.dumps(bit_generator)
-        reloaded = pickle.loads(brng_pkl)
+        bitgen_pkl = pickle.dumps(bit_generator)
+        reloaded = pickle.loads(bitgen_pkl)
         reloaded_state = reloaded.state
         assert_array_equal(Generator(bit_generator).standard_normal(1000),
                            Generator(reloaded).standard_normal(1000))
@@ -264,7 +265,7 @@ class Base(object):
     def test_invalid_state_value(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
-        state['bit_generator'] = 'otherBRNG'
+        state['bit_generator'] = 'otherBitGenerator'
         with pytest.raises(ValueError):
             bit_generator.state = state
 
@@ -359,7 +360,7 @@ class TestThreeFry(Base):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
         keyed = self.bit_generator(counter=state['state']['counter'],
-                          key=state['state']['key'])
+                                   key=state['state']['key'])
         assert_state_equal(bit_generator.state, keyed.state)
 
 
@@ -382,11 +383,10 @@ class TestPhilox(Base):
         bit_generator = self.bit_generator(*self.data1['seed'])
         state = bit_generator.state
         keyed = self.bit_generator(counter=state['state']['counter'],
-                          key=state['state']['key'])
+                                   key=state['state']['key'])
         assert_state_equal(bit_generator.state, keyed.state)
 
 
-
 class TestPCG64(Base):
     @classmethod
     def setup_class(cls):
@@ -453,14 +453,17 @@ class TestMT19937(Base):
         rs = Generator(self.bit_generator(*self.data1['seed']))
         assert_raises(ValueError, rs.bit_generator.seed, 2 ** (self.bits + 1))
         assert_raises(ValueError, rs.bit_generator.seed, -1)
-        assert_raises(ValueError, rs.bit_generator.seed, 2 ** (2 * self.bits + 1))
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      2 ** (2 * self.bits + 1))
 
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(ValueError, rs.bit_generator.seed, [2 ** (self.bits + 1)])
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      [2 ** (self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
-        assert_raises(TypeError, rs.bit_generator.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(TypeError, rs.bit_generator.seed,
+                      [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
@@ -484,7 +487,8 @@ class TestMT19937(Base):
         bit_generator = rs.bit_generator
         state = bit_generator.state
         desired = rs.integers(2 ** 16)
-        tup = (state['bit_generator'], state['state']['key'], state['state']['pos'])
+        tup = (state['bit_generator'], state['state']['key'],
+               state['state']['pos'])
         bit_generator.state = tup
         actual = rs.integers(2 ** 16)
         assert_equal(actual, desired)
@@ -531,9 +535,11 @@ class TestDSFMT(Base):
     def test_seed_out_of_range_array(self):
         # GH #82
         rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(ValueError, rs.bit_generator.seed, [2 ** (self.bits + 1)])
+        assert_raises(ValueError, rs.bit_generator.seed,
+                      [2 ** (self.bits + 1)])
         assert_raises(ValueError, rs.bit_generator.seed, [-1])
-        assert_raises(TypeError, rs.bit_generator.seed, [2 ** (2 * self.bits + 1)])
+        assert_raises(TypeError, rs.bit_generator.seed,
+                      [2 ** (2 * self.bits + 1)])
 
     def test_seed_float(self):
         # GH #82
@@ -546,7 +552,8 @@ class TestDSFMT(Base):
         rs = Generator(self.bit_generator(*self.data1['seed']))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([-np.pi]))
-        assert_raises(TypeError, rs.bit_generator.seed, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, rs.bit_generator.seed,
+                      np.array([np.pi, -np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, np.array([0, np.pi]))
         assert_raises(TypeError, rs.bit_generator.seed, [np.pi])
         assert_raises(TypeError, rs.bit_generator.seed, [0, np.pi])
diff --git a/numpy/random/tests/test_generator_mt19937.py b/numpy/random/tests/test_generator_mt19937.py
index 207ec1a2b..c51164c55 100644
--- a/numpy/random/tests/test_generator_mt19937.py
+++ b/numpy/random/tests/test_generator_mt19937.py
@@ -1,5 +1,4 @@
 import sys
-import warnings
 
 import pytest
 
@@ -208,7 +207,8 @@ class TestIntegers(object):
             assert_equal(self.rfunc(tgt, tgt + is_open, size=1000,
                                     endpoint=endpoint, dtype=dt), tgt)
             assert_equal(self.rfunc([tgt], [tgt + is_open],
-                                    size=1000, endpoint=endpoint, dtype=dt), tgt)
+                                    size=1000, endpoint=endpoint, dtype=dt),
+                         tgt)
 
     def test_rng_zero_and_extremes_array(self, endpoint):
         size = 1000
@@ -295,7 +295,8 @@ class TestIntegers(object):
 
             size = 1000
             random.bit_generator.seed(1234)
-            scalar = self.rfunc(lbnd, ubnd, size=size, endpoint=endpoint, dtype=dt)
+            scalar = self.rfunc(lbnd, ubnd, size=size, endpoint=endpoint,
+                                dtype=dt)
 
             random.bit_generator.seed(1234)
             scalar_array = self.rfunc([lbnd], [ubnd], size=size,
@@ -352,16 +353,18 @@ class TestIntegers(object):
 
             # view as little endian for hash
             random.bit_generator.seed(1234)
-            val = self.rfunc(lbnd, ubnd, size=1000, endpoint=endpoint, dtype=dt)
+            val = self.rfunc(lbnd, ubnd, size=1000, endpoint=endpoint,
+                             dtype=dt)
 
             random.bit_generator.seed(1234)
-            val_bc = self.rfunc([lbnd] * 1000, ubnd, endpoint=endpoint, dtype=dt)
+            val_bc = self.rfunc([lbnd] * 1000, ubnd, endpoint=endpoint,
+                                dtype=dt)
 
             assert_array_equal(val, val_bc)
 
             random.bit_generator.seed(1234)
-            val_bc = self.rfunc([lbnd] * 1000, [ubnd] * 1000, endpoint=endpoint,
-                                dtype=dt)
+            val_bc = self.rfunc([lbnd] * 1000, [ubnd] * 1000,
+                                endpoint=endpoint, dtype=dt)
 
             assert_array_equal(val, val_bc)
 
@@ -457,8 +460,10 @@ class TestIntegers(object):
             sample = self.rfunc(0, 0, (3, 0, 4), endpoint=endpoint, dtype=dt)
             assert sample.shape == (3, 0, 4)
             assert sample.dtype == dt
-            assert self.rfunc(0, -10, 0, endpoint=endpoint, dtype=dt).shape == (0,)
-            assert_equal(random.integers(0, 0, size=(3, 0, 4)).shape, (3, 0, 4))
+            assert self.rfunc(0, -10, 0, endpoint=endpoint,
+                              dtype=dt).shape == (0,)
+            assert_equal(random.integers(0, 0, size=(3, 0, 4)).shape,
+                         (3, 0, 4))
             assert_equal(random.integers(0, -10, size=0).shape, (0,))
             assert_equal(random.integers(10, 10, size=0).shape, (0,))
 
@@ -502,8 +507,8 @@ class TestRandomDist(object):
         # into a C long. Previous implementations of this
         # method have thrown an OverflowError when attempting
         # to generate this integer.
-        actual = random.integers(np.iinfo('l').max,
-                                        np.iinfo('l').max, endpoint=True)
+        actual = random.integers(np.iinfo('l').max, np.iinfo('l').max,
+                                 endpoint=True)
 
         desired = np.iinfo('l').max
         assert_equal(actual, desired)
diff --git a/numpy/random/tests/test_random.py b/numpy/random/tests/test_random.py
index 22e37151c..f192a9141 100644
--- a/numpy/random/tests/test_random.py
+++ b/numpy/random/tests/test_random.py
@@ -43,7 +43,8 @@ class TestSeed(object):
 
     def test_invalid_array_shape(self):
         # gh-9832
-        assert_raises(ValueError, np.random.RandomState, np.array([], dtype=np.int64))
+        assert_raises(ValueError, np.random.RandomState,
+                      np.array([], dtype=np.int64))
         assert_raises(ValueError, np.random.RandomState, [[1, 2, 3]])
         assert_raises(ValueError, np.random.RandomState, [[1, 2, 3],
                                                           [4, 5, 6]])
@@ -449,7 +450,8 @@ class TestRandomDist(object):
         assert_equal(np.random.randint(10, 10, size=0).shape, (0,))
         assert_equal(np.random.choice(0, size=0).shape, (0,))
         assert_equal(np.random.choice([], size=(0,)).shape, (0,))
-        assert_equal(np.random.choice(['a', 'b'], size=(3, 0, 4)).shape, (3, 0, 4))
+        assert_equal(np.random.choice(['a', 'b'], size=(3, 0, 4)).shape,
+                     (3, 0, 4))
         assert_raises(ValueError, np.random.choice, [], 10)
 
     def test_choice_nan_probabilities(self):
@@ -693,7 +695,7 @@ class TestRandomDist(object):
         cov = [[1, 0], [0, 1]]
         size = (3, 2)
         actual = np.random.multivariate_normal(mean, cov, size)
-        desired = np.array([[[1.463620246718631, 11.73759122771936 ],
+        desired = np.array([[[1.463620246718631, 11.73759122771936],
                              [1.622445133300628, 9.771356667546383]],
                             [[2.154490787682787, 12.170324946056553],
                              [1.719909438201865, 9.230548443648306]],
@@ -721,7 +723,7 @@ class TestRandomDist(object):
         assert_raises(ValueError, np.random.multivariate_normal, mean, cov,
                       check_valid='raise')
 
-        cov = np.array([[1, 0.1],[0.1, 1]], dtype=np.float32)
+        cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
         with suppress_warnings() as sup:
             np.random.multivariate_normal(mean, cov)
             w = sup.record(RuntimeWarning)
@@ -917,7 +919,8 @@ class TestRandomDist(object):
                 raise TypeError
 
         throwing_float = np.array(1.0).view(ThrowingFloat)
-        assert_raises(TypeError, np.random.uniform, throwing_float, throwing_float)
+        assert_raises(TypeError, np.random.uniform, throwing_float,
+                      throwing_float)
 
         class ThrowingInteger(np.ndarray):
             def __int__(self):
@@ -1384,21 +1387,24 @@ class TestBroadcast(object):
         assert_array_almost_equal(actual, desired, decimal=14)
         assert_raises(ValueError, triangular, bad_left_one * 3, mode, right)
         assert_raises(ValueError, triangular, left * 3, bad_mode_one, right)
-        assert_raises(ValueError, triangular, bad_left_two * 3, bad_mode_two, right)
+        assert_raises(ValueError, triangular, bad_left_two * 3, bad_mode_two,
+                      right)
 
         self.setSeed()
         actual = triangular(left, mode * 3, right)
         assert_array_almost_equal(actual, desired, decimal=14)
         assert_raises(ValueError, triangular, bad_left_one, mode * 3, right)
         assert_raises(ValueError, triangular, left, bad_mode_one * 3, right)
-        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two * 3, right)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two * 3,
+                      right)
 
         self.setSeed()
         actual = triangular(left, mode, right * 3)
         assert_array_almost_equal(actual, desired, decimal=14)
         assert_raises(ValueError, triangular, bad_left_one, mode, right * 3)
         assert_raises(ValueError, triangular, left, bad_mode_one, right * 3)
-        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two, right * 3)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two,
+                      right * 3)
 
     def test_binomial(self):
         n = [1]
@@ -1536,6 +1542,7 @@ class TestBroadcast(object):
         assert_raises(ValueError, logseries, bad_p_one * 3)
         assert_raises(ValueError, logseries, bad_p_two * 3)
 
+
 class TestThread(object):
     # make sure each state produces the same sequence even in threads
     def setup(self):
@@ -1578,6 +1585,7 @@ class TestThread(object):
             out[...] = state.multinomial(10, [1/6.]*6, size=10000)
         self.check_function(gen_random, sz=(10000, 6))
 
+
 # See Issue #4263
 class TestSingleEltArrayInput(object):
     def setup(self):
diff --git a/numpy/random/tests/test_regression.py b/numpy/random/tests/test_regression.py
index ca9bbbc71..509e2d57f 100644
--- a/numpy/random/tests/test_regression.py
+++ b/numpy/random/tests/test_regression.py
@@ -29,7 +29,8 @@ class TestRegression(object):
         ]
         is_64bits = sys.maxsize > 2**32
         if is_64bits and sys.platform != 'win32':
-            args.append((2**40 - 2, 2**40 - 2, 2**40 - 2)) # Check for 64-bit systems
+            # Check for 64-bit systems
+            args.append((2**40 - 2, 2**40 - 2, 2**40 - 2))
         for arg in args:
             assert_(np.random.hypergeometric(*arg) > 0)
 
diff --git a/numpy/random/tests/test_smoke.py b/numpy/random/tests/test_smoke.py
index a53956193..c94e1a285 100644
--- a/numpy/random/tests/test_smoke.py
+++ b/numpy/random/tests/test_smoke.py
@@ -1,15 +1,13 @@
-import os
 import pickle
-import sys
 import time
 from functools import partial
 
 import numpy as np
 import pytest
-from numpy.testing import (assert_almost_equal, assert_equal, assert_,
-    assert_array_equal, suppress_warnings)
+from numpy.testing import assert_equal, assert_, assert_array_equal
 from numpy.random import (Generator, MT19937, DSFMT, ThreeFry,
-    PCG32, PCG64, Philox, Xoshiro256, Xoshiro512, entropy)
+                          PCG32, PCG64, Philox, Xoshiro256, Xoshiro512,
+                          entropy)
 
 
 @pytest.fixture(scope='module',
@@ -35,10 +33,10 @@ def params_0(f):
 def params_1(f, bounded=False):
     a = 5.0
     b = np.arange(2.0, 12.0)
-    c = np.arange(2.0, 102.0).reshape(10, 10)
-    d = np.arange(2.0, 1002.0).reshape(10, 10, 10)
+    c = np.arange(2.0, 102.0).reshape((10, 10))
+    d = np.arange(2.0, 1002.0).reshape((10, 10, 10))
     e = np.array([2.0, 3.0])
-    g = np.arange(2.0, 12.0).reshape(1, 10, 1)
+    g = np.arange(2.0, 12.0).reshape((1, 10, 1))
     if bounded:
         a = 0.5
         b = b / (1.5 * b.max())
@@ -134,8 +132,8 @@ class RNG(object):
             self.rg.bit_generator.advance(self.advance)
             assert_(not comp_state(state, self.rg.bit_generator.state))
         else:
-            brng_name = self.rg.bit_generator.__class__.__name__
-            pytest.skip('Advance is not supported by {0}'.format(brng_name))
+            bitgen_name = self.rg.bit_generator.__class__.__name__
+            pytest.skip('Advance is not supported by {0}'.format(bitgen_name))
 
     def test_jump(self):
         state = self.rg.bit_generator.state
@@ -149,10 +147,10 @@ class RNG(object):
             rejumped_state = bit_gen3.state
             assert_(comp_state(jumped_state, rejumped_state))
         else:
-            brng_name = self.rg.bit_generator.__class__.__name__
-            if name not in ('',):
-                raise AttributeError('no "jumped" in %s' % brng_name)
-            pytest.skip('Jump is not supported by {0}'.format(brng_name))
+            bitgen_name = self.rg.bit_generator.__class__.__name__
+            if bitgen_name not in ('',):
+                raise AttributeError('no "jumped" in %s' % bitgen_name)
+            pytest.skip('Jump is not supported by {0}'.format(bitgen_name))
 
     def test_uniform(self):
         r = self.rg.uniform(-1.0, 0.0, size=10)
@@ -231,7 +229,8 @@ class RNG(object):
     def test_entropy_init(self):
         rg = Generator(self.bit_generator())
         rg2 = Generator(self.bit_generator())
-        assert_(not comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+        assert_(not comp_state(rg.bit_generator.state,
+                               rg2.bit_generator.state))
 
     def test_seed(self):
         rg = Generator(self.bit_generator(*self.seed))
@@ -440,18 +439,20 @@ class RNG(object):
         pick = pickle.dumps(self.rg)
         unpick = pickle.loads(pick)
         assert_((type(self.rg) == type(unpick)))
-        assert_(comp_state(self.rg.bit_generator.state, unpick.bit_generator.state))
+        assert_(comp_state(self.rg.bit_generator.state,
+                           unpick.bit_generator.state))
 
         pick = pickle.dumps(self.rg)
         unpick = pickle.loads(pick)
         assert_((type(self.rg) == type(unpick)))
-        assert_(comp_state(self.rg.bit_generator.state, unpick.bit_generator.state))
+        assert_(comp_state(self.rg.bit_generator.state,
+                           unpick.bit_generator.state))
 
     def test_seed_array(self):
         if self.seed_vector_bits is None:
-            brng_name = self.bit_generator.__name__
+            bitgen_name = self.bit_generator.__name__
             pytest.skip('Vector seeding is not supported by '
-                        '{0}'.format(brng_name))
+                        '{0}'.format(bitgen_name))
 
         if self.seed_vector_bits == 32:
             dtype = np.uint32