STY: Clean up code

Pep8 fixes
Remove unused imports
Fix name error

15 files changed, 125 insertions, 94 deletions

diff --git a/benchmarks/benchmarks/bench_random.py b/benchmarks/benchmarks/bench_random.py
index 044986029..c9c7baf7c 100644
--- a/benchmarks/benchmarks/bench_random.py
+++ b/benchmarks/benchmarks/bench_random.py
@@ -89,37 +89,37 @@ class RNG(Benchmark):
     params = ['DSFMT', 'PCG64', 'PCG32', 'MT19937', 'Xoshiro256',
               'Xoshiro512', 'Philox', 'ThreeFry', 'numpy']
 
-    def setup(self, brng):
-        if brng == 'numpy':
+    def setup(self, bitgen):
+        if bitgen == 'numpy':
             self.rg = np.random.RandomState()
         else:
-            self.rg = Generator(getattr(np.random, brng)())
+            self.rg = Generator(getattr(np.random, bitgen)())
         self.rg.random()
         self.int32info = np.iinfo(np.int32)
         self.uint32info = np.iinfo(np.uint32)
         self.uint64info = np.iinfo(np.uint64)
 
-    def time_raw(self, brng):
-        if brng == 'numpy':
+    def time_raw(self, bitgen):
+        if bitgen == 'numpy':
             self.rg.random_integers(self.int32info.max, size=nom_size)
         else:
             self.rg.integers(self.int32info.max, size=nom_size, endpoint=True)
 
-    def time_32bit(self, brng):
+    def time_32bit(self, bitgen):
         min, max = self.uint32info.min, self.uint32info.max
-        if brng == 'numpy':
+        if bitgen == 'numpy':
             self.rg.randint(min, max + 1, nom_size, dtype=np.uint32)
         else:
             self.rg.integers(min, max + 1, nom_size, dtype=np.uint32)
 
-    def time_64bit(self, brng):
+    def time_64bit(self, bitgen):
         min, max = self.uint64info.min, self.uint64info.max
-        if brng == 'numpy':
+        if bitgen == 'numpy':
             self.rg.randint(min, max + 1, nom_size, dtype=np.uint64)
         else:
             self.rg.integers(min, max + 1, nom_size, dtype=np.uint64)
 
-    def time_normal_zig(self, brng):
+    def time_normal_zig(self, bitgen):
         self.rg.standard_normal(nom_size)
 
 class Bounded(Benchmark):
@@ -146,14 +146,14 @@ class Bounded(Benchmark):
                [u64, 2047],  # Best case for legacy
              ]]
 
-    def setup(self, brng, args):
-        if brng == 'numpy':
+    def setup(self, bitgen, args):
+        if bitgen == 'numpy':
             self.rg = np.random.RandomState()
         else:
-            self.rg = Generator(getattr(np.random, brng)())
+            self.rg = Generator(getattr(np.random, bitgen)())
         self.rg.random()
 
-    def time_bounded(self, brng, args):
+    def time_bounded(self, bitgen, args):
             """
             Timer for 8-bit bounded values.
 
@@ -165,7 +165,7 @@ class Bounded(Benchmark):
                 Upper bound for range. Lower is always 0.  Must be <= 2**bits.
             """
             dt, max = args
-            if brng == 'numpy':
+            if bitgen == 'numpy':
                 self.rg.randint(0, max + 1, nom_size, dtype=dt)
             else:
                 self.rg.integers(0, max + 1, nom_size, dtype=dt)
diff --git a/numpy/random/__init__.py b/numpy/random/__init__.py
index ade912839..2e83e419d 100644
--- a/numpy/random/__init__.py
+++ b/numpy/random/__init__.py
@@ -173,13 +173,14 @@ from .xoshiro256 import Xoshiro256
 from .xoshiro512 import Xoshiro512
 from .mtrand import RandomState
 
-__all__ += ['Generator', 'DSFMT', 'MT19937', 'Philox','PCG64', 'PCG32',
-           'ThreeFry', 'Xoshiro256', 'Xoshiro512', 'RandomState']
+__all__ += ['Generator', 'DSFMT', 'MT19937', 'Philox', 'PCG64', 'PCG32',
+            'ThreeFry', 'Xoshiro256', 'Xoshiro512', 'RandomState']
 
 # Some aliases:
 ranf = random = sample = random_sample
 __all__.extend(['ranf', 'random', 'sample'])
 
+
 def __RandomState_ctor():
     """Return a RandomState instance.
 
@@ -195,6 +196,7 @@ def __RandomState_ctor():
     """
     return RandomState(seed=0)
 
+
 from numpy._pytesttester import PytestTester
 test = PytestTester(__name__)
 del PytestTester
diff --git a/numpy/random/_pickle.py b/numpy/random/_pickle.py
index cc624a1e8..307ffe61e 100644
--- a/numpy/random/_pickle.py
+++ b/numpy/random/_pickle.py
@@ -38,7 +38,8 @@ def __generator_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return Generator(bit_generator())
 
@@ -60,10 +61,12 @@ def __bit_generator_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return bit_generator()
 
+
 def __randomstate_ctor(bit_generator_name='mt19937'):
     """
     Pickling helper function that returns a legacy RandomState-like object
@@ -81,6 +84,7 @@ def __randomstate_ctor(bit_generator_name='mt19937'):
     if bit_generator_name in BitGenerators:
         bit_generator = BitGenerators[bit_generator_name]
     else:
-        raise ValueError(str(bit_generator_name) + ' is not a known BitGenerator module.')
+        raise ValueError(str(bit_generator_name) + ' is not a known '
+                                                   'BitGenerator module.')
 
     return RandomState(bit_generator())
diff --git a/numpy/random/common.pyx b/numpy/random/common.pyx
index 994de4345..0fd2d154a 100644
--- a/numpy/random/common.pyx
+++ b/numpy/random/common.pyx
@@ -45,6 +45,10 @@ cdef object random_raw(bitgen_t *bitgen, object lock, object size, object output
 
     Parameters
     ----------
+    bitgen : BitGenerator
+        Address of the bit generator struct
+    lock : Threading.Lock
+        Lock provided by the bit generator
     size : int or tuple of ints, optional
         Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
         ``m * n * k`` samples are drawn.  Default is None, in which case a
diff --git a/numpy/random/distributions.pxd b/numpy/random/distributions.pxd
index 5d6f08417..2f336a17d 100644
--- a/numpy/random/distributions.pxd
+++ b/numpy/random/distributions.pxd
@@ -1,7 +1,7 @@
 #cython: language_level=3
 
 from libc.stdint cimport (uint8_t, uint16_t, uint32_t, uint64_t,
-                          int8_t, int16_t, int32_t, int64_t, intptr_t)
+                          int32_t, int64_t)
 import numpy as np
 cimport numpy as np
 
diff --git a/numpy/random/dsfmt.pyx b/numpy/random/dsfmt.pyx
index ea77b7821..65475e30d 100644
--- a/numpy/random/dsfmt.pyx
+++ b/numpy/random/dsfmt.pyx
@@ -1,6 +1,5 @@
 import operator
 from cpython.pycapsule cimport PyCapsule_New
-from libc.string cimport memcpy
 
 try:
     from threading import Lock
diff --git a/numpy/random/examples/numba/extending_distributions.py b/numpy/random/examples/numba/extending_distributions.py
index f1f9003a9..1172e51de 100644
--- a/numpy/random/examples/numba/extending_distributions.py
+++ b/numpy/random/examples/numba/extending_distributions.py
@@ -5,7 +5,8 @@ export PYTHON_INCLUDE=#path to Python's include folder, usually \
     ${PYTHON_HOME}/include/python${PYTHON_VERSION}m
 export NUMPY_INCLUDE=#path to numpy's include folder, usually \
     ${PYTHON_HOME}/lib/python${PYTHON_VERSION}/site-packages/numpy/core/include
-gcc -shared -o libdistributions.so -fPIC distributions.c -I${NUMPY_INCLUDE} -I${PYTHON_INCLUDE}
+gcc -shared -o libdistributions.so -fPIC distributions.c \
+    -I${NUMPY_INCLUDE} -I${PYTHON_INCLUDE}
 mv libdistributions.so ../../examples/numba/
 
 On Windows
diff --git a/numpy/random/generator.pyx b/numpy/random/generator.pyx
index ae920fc9f..ca5d4293c 100644
--- a/numpy/random/generator.pyx
+++ b/numpy/random/generator.pyx
@@ -3872,7 +3872,7 @@ cdef class Generator:
                [3, 4, 5]])
 
         """
-        if isinstance(x, (int, long, np.integer)):
+        if isinstance(x, (int, np.integer)):
             arr = np.arange(x)
             self.shuffle(arr)
             return arr
diff --git a/numpy/random/mtrand.pyx b/numpy/random/mtrand.pyx
index ecbd8401a..f1d45668e 100644
--- a/numpy/random/mtrand.pyx
+++ b/numpy/random/mtrand.pyx
@@ -3704,7 +3704,7 @@ cdef class RandomState:
         cov = np.array(cov)
         if size is None:
             shape = []
-        elif isinstance(size, (int, long, np.integer)):
+        elif isinstance(size, (int, np.integer)):
             shape = [size]
         else:
             shape = size
@@ -4134,7 +4134,7 @@ cdef class RandomState:
                [3, 4, 5]])
 
         """
-        if isinstance(x, (int, long, np.integer)):
+        if isinstance(x, (int, np.integer)):
             arr = np.arange(x)
             self.shuffle(arr)
             return arr
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
diff --git a/numpy/random/xoshiro512.pyx b/numpy/random/xoshiro512.pyx
index 27c26486a..4a6db3b23 100644
--- a/numpy/random/xoshiro512.pyx
+++ b/numpy/random/xoshiro512.pyx
@@ -3,7 +3,6 @@ try:
 except ImportError:
     from dummy_threading import Lock
 
-from libc.string cimport memcpy
 from cpython.pycapsule cimport PyCapsule_New
 
 import numpy as np