Apply isort to tests.gpuarray sub-package modules

tests/gpuarray/check_dnn_conv.py

@@ -13,39 +13,26 @@
 # Else, any arg will be directly passed to pytest.
 # python check_dnn_conv.py -xvs  # verbose mode, capture output, exit at first error.
 
-import sys
 import math
-
-import pytest
+import sys
+from itertools import chain, product
 
 import numpy as np
-
-import theano
+import pytest
 
 import tests.unittest_tools as utt
-
-from itertools import product, chain
-
+import theano
+from tests.gpuarray.config import mode_with_gpu, ref_cast
 from theano.configdefaults import SUPPORTED_DNN_CONV_ALGO_RUNTIME
 from theano.gpuarray import cudnn_defs
-from theano.gpuarray.dnn import (
-    GpuDnnConv,
-    GpuDnnConvGradW,
-    GpuDnnConvGradI,
-    version,
-    _dnn_conv as dnn_conv,
-    _dnn_gradinput as dnn_gradinput,
-    _dnn_gradweight as dnn_gradweight,
-)
-from theano.tensor.nnet.abstract_conv import get_conv_output_shape, assert_conv_shape
+from theano.gpuarray.dnn import GpuDnnConv, GpuDnnConvGradI, GpuDnnConvGradW
+from theano.gpuarray.dnn import _dnn_conv as dnn_conv
+from theano.gpuarray.dnn import _dnn_gradinput as dnn_gradinput
+from theano.gpuarray.dnn import _dnn_gradweight as dnn_gradweight
+from theano.gpuarray.dnn import version
+from theano.tensor.nnet.abstract_conv import assert_conv_shape, get_conv_output_shape
 from theano.tensor.nnet.corr import CorrMM, CorrMM_gradInputs, CorrMM_gradWeights
-from theano.tensor.nnet.corr3d import (
-    Corr3dMM,
-    Corr3dMMGradInputs,
-    Corr3dMMGradWeights,
-)
-
-from tests.gpuarray.config import mode_with_gpu, ref_cast
+from theano.tensor.nnet.corr3d import Corr3dMM, Corr3dMMGradInputs, Corr3dMMGradWeights
 
 
 def check_dtype_config_support(dtype, precision):

tests/gpuarray/config.py

 import pytest
 
-import theano.tensor
 import theano.gpuarray
+import theano.tensor
 
 
 if theano.gpuarray.pygpu is None:

tests/gpuarray/run_dnn_conv.py

@@ -2,30 +2,23 @@
 # This script should not be imported, but only used as a program.
 # python run_dnn_conv.py --help         # Print help.
 # python run_dnn_conv.py {fwd|bwd-filter|bwd-data} {2d|3d} -a <algo> -i <inputShape> -f <filterShape> ...
-import sys
 import argparse
+import sys
 
 import theano
-
+from tests.gpuarray.check_dnn_conv import CheckDnn, TestDnnConv2D, TestDnnConv3D, cudnn
 from theano.configdefaults import SUPPORTED_DNN_CONV_ALGO_RUNTIME
 from theano.gpuarray.cudnn_defs import (
-    HALF,
-    FLOAT,
     DOUBLE,
-    TRUE_HALF_CONFIG,
-    PSEUDO_HALF_CONFIG,
-    FLOAT_CONFIG,
     DOUBLE_CONFIG,
+    FLOAT,
+    FLOAT_CONFIG,
+    HALF,
+    PSEUDO_HALF_CONFIG,
+    TRUE_HALF_CONFIG,
 )
 from theano.tensor.nnet.abstract_conv import get_conv_output_shape
 
-from tests.gpuarray.check_dnn_conv import (
-    cudnn,
-    TestDnnConv2D,
-    TestDnnConv3D,
-    CheckDnn,
-)
-
 
 if __name__ != "__main__":
     raise ImportError("This script must not be imported.")

tests/gpuarray/test_abstractconv.py

+import numpy as np
 import pytest
 
-import numpy as np
 
 pygpu = pytest.importorskip("pygpu")
 gpuarray = pygpu.gpuarray
 
-from theano.gpuarray.type import GpuArrayType, gpuarray_shared_constructor, get_context
-from theano.gpuarray.dnn import (
-    dnn_available,
-    GpuDnnConv,
-    GpuDnnConvGradW,
-    GpuDnnConvGradI,
+from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from tests.tensor.nnet.test_abstract_conv import (
+    BaseTestConv2d,
+    BaseTestConv3d,
+    TestConv2dTranspose,
+    TestConvTypes,
 )
 from theano.gpuarray.blas import (
-    GpuCorrMM,
-    GpuCorrMM_gradWeights,
-    GpuCorrMM_gradInputs,
     GpuCorr3dMM,
-    GpuCorr3dMM_gradWeights,
     GpuCorr3dMM_gradInputs,
+    GpuCorr3dMM_gradWeights,
+    GpuCorrMM,
+    GpuCorrMM_gradInputs,
+    GpuCorrMM_gradWeights,
 )
-
-from tests.tensor.nnet.test_abstract_conv import (
-    BaseTestConv2d,
-    BaseTestConv3d,
-    TestConvTypes,
-    TestConv2dTranspose,
+from theano.gpuarray.dnn import (
+    GpuDnnConv,
+    GpuDnnConvGradI,
+    GpuDnnConvGradW,
+    dnn_available,
 )
-from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor
 
 
 gpu_ftensor4 = GpuArrayType(dtype="float32", broadcastable=(False,) * 4)

tests/gpuarray/test_basic_ops.py

 import pytest
 
+
 pygpu = pytest.importorskip("pygpu")
 gpuarray = pygpu.gpuarray
 import numpy as np
+
 import theano
 import theano.tensor as tt
-
-from theano.tensor import TensorType
-from theano.tensor.basic import alloc
-
-# Don't import test classes otherwise they get tested as part of the file
-from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
+from tests.tensor.test_basic import (
+    TestAlloc,
+    TestComparison,
+    TestJoinAndSplit,
+    TestReshape,
+    rand,
+    safe_make_node,
+)
 from theano.gpuarray.basic_ops import (
-    host_from_gpu,
-    HostFromGpu,
-    GpuFromHost,
-    GpuReshape,
-    GpuToGpu,
     GpuAlloc,
     GpuAllocEmpty,
     GpuContiguous,
-    gpu_join,
+    GpuEye,
+    GpuFromHost,
     GpuJoin,
+    GpuReshape,
     GpuSplit,
-    GpuEye,
+    GpuToGpu,
     GpuTri,
+    HostFromGpu,
     gpu_contiguous,
+    gpu_join,
+    host_from_gpu,
 )
 from theano.gpuarray.elemwise import GpuDimShuffle, GpuElemwise
 from theano.gpuarray.subtensor import GpuSubtensor
 
-from tests import unittest_tools as utt
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
-from tests.tensor.test_basic import (
-    rand,
-    safe_make_node,
-    TestAlloc,
-    TestComparison,
-    TestReshape,
-    TestJoinAndSplit,
-)
+# Don't import test classes otherwise they get tested as part of the file
+from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor
+from theano.tensor import TensorType
+from theano.tensor.basic import alloc
 
 
 utt.seed_rng()
@@ -68,7 +68,7 @@ def inplace_func(
 
 
 def fake_shared(value, name=None, strict=False, allow_downcast=None, **kwargs):
-    from theano.tensor.sharedvar import tensor_constructor, scalar_constructor
+    from theano.tensor.sharedvar import scalar_constructor, tensor_constructor
 
     for c in (gpuarray_shared_constructor, tensor_constructor, scalar_constructor):
         try:

tests/gpuarray/test_blas.py

 import itertools
+
 import numpy as np
 
 import theano
-from theano import config
-from theano import tensor
-from theano.tensor.blas import gemv, gemv_inplace, gemm_inplace, _dot22, batched_dot
-
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from tests.gpuarray.test_basic_ops import makeTester, rand
+from tests.tensor.test_blas import BaseGemv, TestGer
+from theano import config, tensor
 from theano.gpuarray import gpuarray_shared_constructor
 from theano.gpuarray.blas import (
-    gpugemv_inplace,
-    gpugemv_no_inplace,
+    GpuGemm,
+    GpuGer,
+    gpu_dot22,
     gpugemm_inplace,
     gpugemm_no_inplace,
     gpugemmbatch_inplace,
+    gpugemv_inplace,
+    gpugemv_no_inplace,
     gpuger_inplace,
     gpuger_no_inplace,
-    GpuGer,
-    GpuGemm,
-    gpu_dot22,
 )
-
-from tests import unittest_tools as utt
-from tests.tensor.test_blas import TestGer, BaseGemv
-from tests.gpuarray.config import mode_with_gpu, test_ctx_name
-from tests.gpuarray.test_basic_ops import makeTester, rand
+from theano.tensor.blas import _dot22, batched_dot, gemm_inplace, gemv, gemv_inplace
 
 
 TestGpuGemv = makeTester(

tests/gpuarray/test_blocksparse.py

-import pytest
-
 import numpy as np
-
-import theano
+import pytest
 
 import tests.unittest_tools as utt
-
+import theano
+from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from tests.tensor.nnet.test_blocksparse import TestBlockSparseGemvAndOuter
 from theano import tensor
-from theano.gpuarray.type import gpuarray_shared_constructor
 from theano.gpuarray.blocksparse import (
     GpuSparseBlockGemv,
     GpuSparseBlockOuter,
     gpu_sparse_block_gemv,
     gpu_sparse_block_outer,
 )
-
-from tests.gpuarray.config import mode_with_gpu, test_ctx_name
-from tests.tensor.nnet.test_blocksparse import TestBlockSparseGemvAndOuter
+from theano.gpuarray.type import gpuarray_shared_constructor
 
 
 class TestBlockSparseGemvAndOuterGPUarray(TestBlockSparseGemvAndOuter):

tests/gpuarray/test_cgpukernelbase.py

-import pytest
 import numpy as np
-import theano
-
+import pytest
 
-from theano import tensor, config, Apply, Op
-from theano.scalar import int32 as int_t
+import theano
+from theano import Apply, Op, config, tensor
 from theano.gof import ParamsType
-from theano.gradient import grad_undefined
-
 from theano.gpuarray.basic_ops import CGpuKernelBase
 from theano.gpuarray.type import GpuArrayType, get_context, gpu_context_type
+from theano.gradient import grad_undefined
+from theano.scalar import int32 as int_t
 
 
 # This is an implementation to test that CGpuKernelBase works and also

tests/gpuarray/test_ctc.py

-import pytest
 import numpy as np
+import pytest
 
 import theano
-import theano.tensor as tt
 import theano.gpuarray
-
-from theano.gpuarray.ctc import gpu_ctc, GpuConnectionistTemporalClassification
+import theano.tensor as tt
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
+from tests.tensor.nnet.test_ctc import setup_ctc_case, setup_grad_case, setup_torch_case
+from theano.gpuarray.ctc import GpuConnectionistTemporalClassification, gpu_ctc
 from theano.tensor.nnet.ctc import (
+    ConnectionistTemporalClassification,
     ctc,
     ctc_available,
-    ConnectionistTemporalClassification,
-)
-
-from tests import unittest_tools as utt
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
-from tests.tensor.nnet.test_ctc import (
-    setup_torch_case,
-    setup_ctc_case,
-    setup_grad_case,
 )
 
 

tests/gpuarray/test_dnn.py

 import logging
-import pytest
+
 import numpy as np
+import pytest
 
-pygpu = pytest.importorskip("pygpu")  # noqa
 
-import theano
-import theano.tensor as tt
-import tests.unittest_tools as utt
+pygpu = pytest.importorskip("pygpu")  # noqa
 
-from itertools import product, chain
 from collections import OrderedDict
+from itertools import chain, product
 
 from six import StringIO
 
+import tests.unittest_tools as utt
+import theano
+import theano.tensor as tt
+from tests.gpuarray import test_nnet
+from tests.gpuarray.config import (
+    mode_with_gpu,
+    mode_without_gpu,
+    ref_cast,
+    test_ctx_name,
+)
+from tests.gpuarray.rnn_support import GRU, LSTM, Model, WrapperLayer
+from tests.tensor.nnet.test_abstract_conv import (
+    TestGroupedConv3dNoOptim,
+    TestGroupedConvNoOptim,
+)
+from theano.configdefaults import SUPPORTED_DNN_CONV_ALGO_FWD
+from theano.gpuarray import dnn
+from theano.gpuarray.basic_ops import GpuAllocEmpty
+from theano.gpuarray.type import GpuArrayType, gpuarray_shared_constructor
 from theano.tensor.nnet import (
-    bn,
-    softmax_op,
-    SoftmaxGrad,
-    softmax,
     LogSoftmax,
     Softmax,
+    SoftmaxGrad,
+    bn,
     conv2d,
+    softmax,
+    softmax_op,
 )
-from theano.tensor.nnet.corr3d import Corr3dMM
-from theano.tensor.nnet.corr import CorrMM
 from theano.tensor.nnet.abstract_conv import (
-    get_conv_output_shape,
     get_conv_gradinputs_shape,
+    get_conv_output_shape,
 )
-from theano.tensor.signal.pool import pool_2d, pool_3d
-from theano.tensor.signal.pool import Pool, MaxPoolGrad, AveragePoolGrad
-
-from theano.configdefaults import SUPPORTED_DNN_CONV_ALGO_FWD
-
-from theano.gpuarray import dnn
-from theano.gpuarray.basic_ops import GpuAllocEmpty
-from theano.gpuarray.type import gpuarray_shared_constructor, GpuArrayType
-
-from tests.tensor.nnet.test_abstract_conv import (
-    TestGroupedConvNoOptim,
-    TestGroupedConv3dNoOptim,
-)
-
-from tests.gpuarray import test_nnet
-from tests.gpuarray.config import (
-    mode_with_gpu,
-    mode_without_gpu,
-    test_ctx_name,
-    ref_cast,
+from theano.tensor.nnet.corr import CorrMM
+from theano.tensor.nnet.corr3d import Corr3dMM
+from theano.tensor.signal.pool import (
+    AveragePoolGrad,
+    MaxPoolGrad,
+    Pool,
+    pool_2d,
+    pool_3d,
 )
-from tests.gpuarray.rnn_support import Model, GRU, LSTM, WrapperLayer
 
 
 if not dnn.dnn_available(test_ctx_name):

tests/gpuarray/test_elemwise.py

-import pytest
 import numpy as np
+import pytest
+
 import theano
 
+
 pygpu = pytest.importorskip("pygpu")
 gpuarray = pygpu.ndgpuarray
 
 from copy import copy
 
-from theano import scalar, gof, tensor
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
+from tests.gpuarray.test_basic_ops import rand_gpuarray
+from tests.tensor import test_elemwise
+from tests.unittest_tools import assert_allclose
+from theano import gof, scalar, tensor
 from theano.compile import DebugMode, Mode
-
+from theano.gpuarray.dnn import GpuDnnReduction
 from theano.gpuarray.elemwise import (
-    GpuElemwise,
-    GpuDimShuffle,
-    GpuCAReduceCuda,
     GpuCAReduceCPY,
-    GpuErfinv,
+    GpuCAReduceCuda,
+    GpuDimShuffle,
+    GpuElemwise,
     GpuErfcinv,
+    GpuErfinv,
 )
-from theano.gpuarray.dnn import GpuDnnReduction
 from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor
 
-from tests.tensor import test_elemwise
-from tests.unittest_tools import assert_allclose
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
-from tests.gpuarray.test_basic_ops import rand_gpuarray
-
 
 # This is actually a test for GpuElemwise
 class TestGpuBroadcast(test_elemwise.TestBroadcast):

tests/gpuarray/test_extra_ops.py

-import pytest
+from functools import partial
+from itertools import product
 
 import numpy as np
+import pytest
 
 import theano
 import theano.tensor as tt
-
-from functools import partial
-from itertools import product
-
-from theano.tensor.extra_ops import CumOp
-from theano.gpuarray.extra_ops import GpuCumOp
-from theano.gpuarray.type import get_context
-
 from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu, test_ctx_name
 from tests.tensor.test_extra_ops import TestCumOp
+from theano.gpuarray.extra_ops import GpuCumOp
+from theano.gpuarray.type import get_context
+from theano.tensor.extra_ops import CumOp
 
 
 class TestGpuCumOp(TestCumOp):

tests/gpuarray/test_fft.py

 import numpy as np
-
 import pytest
 
 import theano
-import theano.tensor as tt
 import theano.gpuarray.fft
-
-from theano.gpuarray.fft import pygpu_available, skcuda_available, pycuda_available
-
+import theano.tensor as tt
 from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu
+from theano.gpuarray.fft import pycuda_available, pygpu_available, skcuda_available
+
 
 # Skip tests if pygpu is not available.
 if not pygpu_available:  # noqa

tests/gpuarray/test_gemmcorr.py

 import numpy as np
 
 import theano
-
-from theano import config
-from theano.tensor.nnet.corr import CorrMM, CorrMM_gradWeights, CorrMM_gradInputs
-from theano.gpuarray.type import gpuarray_shared_constructor
-from theano.gpuarray.blas import GpuCorrMM, GpuCorrMM_gradWeights, GpuCorrMM_gradInputs
-
 from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, ref_cast
-from tests.tensor.nnet.test_abstract_conv import (
-    TestGroupedConvNoOptim,
-    TestUnsharedConv,
-)
 from tests.tensor.nnet.test_abstract_conv import (
     TestAsymmetricPadding,
     TestCausalConv,
+    TestGroupedConvNoOptim,
+    TestUnsharedConv,
 )
+from theano import config
+from theano.gpuarray.blas import GpuCorrMM, GpuCorrMM_gradInputs, GpuCorrMM_gradWeights
+from theano.gpuarray.type import gpuarray_shared_constructor
+from theano.tensor.nnet.corr import CorrMM, CorrMM_gradInputs, CorrMM_gradWeights
 
 
 class TestCorrMM:

tests/gpuarray/test_gemmcorr3d.py

 import numpy as np
 
 import theano
-
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, ref_cast
+from tests.tensor.nnet.test_abstract_conv import TestGroupedConv3dNoOptim
 from theano import config
-
-from theano.tensor.nnet.corr3d import (
-    Corr3dMM,
-    Corr3dMMGradWeights,
-    Corr3dMMGradInputs,
-)
-
-from theano.gpuarray.type import gpuarray_shared_constructor
 from theano.gpuarray.blas import (
     GpuCorr3dMM,
-    GpuCorr3dMM_gradWeights,
     GpuCorr3dMM_gradInputs,
+    GpuCorr3dMM_gradWeights,
 )
-
-from tests import unittest_tools as utt
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, ref_cast
-from tests.tensor.nnet.test_abstract_conv import TestGroupedConv3dNoOptim
+from theano.gpuarray.type import gpuarray_shared_constructor
+from theano.tensor.nnet.corr3d import Corr3dMM, Corr3dMMGradInputs, Corr3dMMGradWeights
 
 
 class TestCorr3dMM:

tests/gpuarray/test_linalg.py

-import pytest
-
 import numpy as np
-
-import theano
-
+import pytest
 from numpy.linalg.linalg import LinAlgError
 
+import theano
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
+from tests.gpuarray.test_basic_ops import rand
 from theano import config
+from theano.gpuarray import gpuarray_shared_constructor
 from theano.gpuarray.linalg import (
-    GpuCusolverSolve,
-    GpuCublasTriangularSolve,
     GpuCholesky,
+    GpuCublasTriangularSolve,
+    GpuCusolverSolve,
     GpuMagmaCholesky,
     GpuMagmaEigh,
     GpuMagmaMatrixInverse,
     GpuMagmaQR,
     GpuMagmaSVD,
     cusolver_available,
-    gpu_matrix_inverse,
     gpu_cholesky,
+    gpu_matrix_inverse,
+    gpu_qr,
     gpu_solve,
     gpu_solve_lower_triangular,
     gpu_svd,
-    gpu_qr,
 )
 from theano.tensor.nlinalg import (
     SVD,
@@ -34,11 +35,6 @@ from theano.tensor.nlinalg import (
     qr,
 )
 from theano.tensor.slinalg import Cholesky, cholesky, imported_scipy
-from theano.gpuarray import gpuarray_shared_constructor
-
-from tests import unittest_tools as utt
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
-from tests.gpuarray.test_basic_ops import rand
 
 
 @pytest.mark.skipif(

tests/gpuarray/test_misc.py

@@ -3,12 +3,10 @@
 import numpy as np
 
 import theano
-
+from tests.gpuarray.config import mode_with_gpu
 from theano import tensor
 from theano.compile.nanguardmode import NanGuardMode
 
-from tests.gpuarray.config import mode_with_gpu
-
 
 def test_nan_guard_mode():
     # Also test that abs uint* and bool have c code.

tests/gpuarray/test_multinomial.py

 import os
+from pickle import Unpickler
 
-import pytest
 import numpy as np
-
-import theano
+import pytest
 
 import tests.unittest_tools as utt
-
-from pickle import Unpickler
-
+import theano
+from tests.gpuarray.config import mode_with_gpu
 from theano import config, function, tensor
 from theano.compat import PY3
-from theano.sandbox import multinomial
-from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
 from theano.gpuarray.multinomial import (
-    GPUAMultinomialFromUniform,
     GPUAChoiceFromUniform,
+    GPUAMultinomialFromUniform,
 )
-
-from tests.gpuarray.config import mode_with_gpu
+from theano.sandbox import multinomial
+from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
 
 
 def test_multinomial_output_dtype():

tests/gpuarray/test_neighbours.py

-from theano.gpuarray.neighbours import GpuImages2Neibs
-
-from tests.tensor.nnet import test_neighbours
 from tests.gpuarray.config import mode_with_gpu
+from tests.tensor.nnet import test_neighbours
+from theano.gpuarray.neighbours import GpuImages2Neibs
 
 
 class TestGpuImages2Neibs(test_neighbours.TestImages2Neibs):

tests/gpuarray/test_nnet.py

 import numpy as np
 
+import tests.unittest_tools as utt
 import theano
 import theano.tensor as tt
-
-import tests.unittest_tools as utt
-
-from theano.tensor.nnet import crossentropy_softmax_1hot_with_bias_dx
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
 from theano.gpuarray.nnet import (
-    GpuCrossentropySoftmaxArgmax1HotWithBias,
     GpuCrossentropySoftmax1HotWithBiasDx,
-    GpuSoftmaxWithBias,
+    GpuCrossentropySoftmaxArgmax1HotWithBias,
     GpuSoftmax,
+    GpuSoftmaxWithBias,
 )
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
+from theano.tensor.nnet import crossentropy_softmax_1hot_with_bias_dx
+
 
 mode_wo_cudnn = mode_with_gpu.excluding("cudnn")
 

tests/gpuarray/test_opt.py

 import numpy as np
-
 import pytest
 
 import theano
 import theano.gpuarray
 import theano.tensor.slinalg as slinalg
-
+from tests import test_ifelse
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
+from tests.tensor import test_basic
 from theano import tensor
-from theano.gof.opt import check_stack_trace
-from theano.tensor.nnet import abstract_conv
 from theano.breakpoint import PdbBreakpoint
-from theano.gpuarray import basic_ops
-from theano.gpuarray.type import GpuArrayType, gpuarray_shared_constructor, get_context
+from theano.gof.opt import check_stack_trace
+from theano.gpuarray import basic_ops, blas, dnn, opt
 from theano.gpuarray.basic_ops import (
     GpuAlloc,
     GpuAllocEmpty,
-    GpuReshape,
     GpuFromHost,
+    GpuReshape,
     HostFromGpu,
     host_from_gpu,
 )
 from theano.gpuarray.blas import GpuGemm
+from theano.gpuarray.dnn import GpuDnnReduction
 from theano.gpuarray.elemwise import (
-    GpuCAReduceCuda,
+    Elemwise,
     GpuCAReduceCPY,
+    GpuCAReduceCuda,
     GpuElemwise,
-    Elemwise,
     max_inputs_to_GpuElemwise,
 )
-from theano.gpuarray import dnn, blas, opt
-from theano.gpuarray.dnn import GpuDnnReduction
+from theano.gpuarray.linalg import GpuCholesky, GpuCusolverSolve, cusolver_available
 from theano.gpuarray.subtensor import GpuSubtensor
-from theano.gpuarray.linalg import GpuCusolverSolve, cusolver_available, GpuCholesky
-
-from tests import unittest_tools as utt, test_ifelse
-from tests.tensor import test_basic
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name
+from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor
+from theano.tensor.nnet import abstract_conv
 
 
 def _check_stack_trace(thing):

tests/gpuarray/test_others.py

-import pytest
 import numpy as np
+import pytest
+
 
 pygpu = pytest.importorskip("pygpu")
 
-from theano.misc.pkl_utils import dump, load
-from theano.gpuarray.basic_ops import HostFromGpu, GpuFromHost
+from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from tests.misc.test_may_share_memory import may_share_memory_core
+from tests.tensor import test_opt
+from theano.gpuarray.basic_ops import GpuFromHost, HostFromGpu
 from theano.gpuarray.type import (
-    get_context,
-    GpuArrayType,
     GpuArraySharedVariable,
+    GpuArrayType,
+    get_context,
     gpuarray_shared_constructor,
 )
-
-from tests.tensor import test_opt
-from tests.misc.test_may_share_memory import may_share_memory_core
-from tests.gpuarray.config import test_ctx_name, mode_with_gpu
+from theano.misc.pkl_utils import dump, load
 
 
 class TestFusion(test_opt.TestFusion):

tests/gpuarray/test_pickle.py

@@ -8,17 +8,15 @@ regular test file.
 
 import os
 import sys
-
-import pytest
+from pickle import Unpickler
 
 import numpy as np
-
-from pickle import Unpickler
+import pytest
 
 from theano import config
-
 from theano.gpuarray.type import ContextNotDefined
 
+
 try:
     import pygpu  # noqa: F401
 

tests/gpuarray/test_pool.py

 import copy
 import itertools
 
-import pytest
-
 import numpy as np
+import pytest
 
 import theano
-
-from theano import gradient
-from theano import tensor
-from theano.tensor.signal.pool import (
-    Pool,
-    MaxPoolGrad,
-    AveragePoolGrad,
-    DownsampleFactorMaxGradGrad,
-)
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
+from tests.gpuarray.test_basic_ops import rand
+from theano import gradient, tensor
 from theano.gpuarray.pool import (
-    GpuPool,
-    GpuMaxPoolGrad,
     GpuAveragePoolGrad,
     GpuDownsampleFactorMaxGradGrad,
+    GpuMaxPoolGrad,
+    GpuPool,
+)
+from theano.tensor.signal.pool import (
+    AveragePoolGrad,
+    DownsampleFactorMaxGradGrad,
+    MaxPoolGrad,
+    Pool,
 )
-
-from tests import unittest_tools as utt
-from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
-from tests.gpuarray.test_basic_ops import rand
 
 
 class TestPool:

tests/gpuarray/test_reduction.py

 import math
 
-import pytest
-
 import numpy as np
+import pytest
 
 import theano
 import theano.tensor as tt
-
-from theano.gpuarray import GpuArrayType
-from theano.gpuarray.reduction import GpuMaxAndArgmax
-from theano.gpuarray.dnn import GpuDnnReduction
-
 from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu, mode_without_gpu
 from tests.gpuarray.test_basic_ops import rand_gpuarray
+from theano.gpuarray import GpuArrayType
+from theano.gpuarray.dnn import GpuDnnReduction
+from theano.gpuarray.reduction import GpuMaxAndArgmax
 
 
 # Number of values to be used in test tensors (except with 0-D tensors!).

tests/gpuarray/test_rng_mrg.py

@@ -3,17 +3,15 @@ import functools
 import numpy as np
 
 import theano
-
-from theano import change_flags, tensor
-from theano.sandbox import rng_mrg
-from theano.sandbox.rng_mrg import MRG_RandomStreams
-from theano.gpuarray.type import gpuarray_shared_constructor
-from theano.gpuarray.rng_mrg import GPUA_mrg_uniform
-
 from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu as mode
 from tests.sandbox.test_rng_mrg import java_samples, rng_mrg_overflow
 from tests.sandbox.test_rng_mrg import test_f16_nonzero as cpu_f16_nonzero
+from theano import change_flags, tensor
+from theano.gpuarray.rng_mrg import GPUA_mrg_uniform
+from theano.gpuarray.type import gpuarray_shared_constructor
+from theano.sandbox import rng_mrg
+from theano.sandbox.rng_mrg import MRG_RandomStreams
 
 
 utt.seed_rng()

tests/gpuarray/test_scan.py

 import numpy as np
 
 import theano
-
 import theano.sandbox.rng_mrg
-
+from tests import unittest_tools as utt
 from tests.gpuarray.config import mode_with_gpu, test_ctx_name
 from theano.gpuarray.basic_ops import GpuFromHost, HostFromGpu
 from theano.gpuarray.elemwise import GpuElemwise
 
-from tests import unittest_tools as utt
-
 
 class TestScan:
     def setup_method(self):

tests/gpuarray/test_sort.py

-from theano.gpuarray.sort import GpuTopKOp
-
-from tests.tensor.test_sort import TestTopK
 from tests.gpuarray.config import mode_with_gpu
+from tests.tensor.test_sort import TestTopK
+from theano.gpuarray.sort import GpuTopKOp
 
 
 class TestGpuTopK(TestTopK):

tests/gpuarray/test_subtensor.py

 import numpy as np
 
 import theano
-
+from tests import unittest_tools as utt
+from tests.gpuarray.config import mode_with_gpu, test_ctx_name
+from tests.tensor.test_basic import TestAllocDiag
+from tests.tensor.test_subtensor import TestAdvancedSubtensor, TestSubtensor
 from theano import tensor
 from theano.compile import DeepCopyOp
-from theano.gpuarray.basic_ops import HostFromGpu, GpuFromHost, GpuContiguous
+from theano.gpuarray.basic_ops import GpuContiguous, GpuFromHost, HostFromGpu
 from theano.gpuarray.elemwise import GpuDimShuffle
 from theano.gpuarray.subtensor import (
-    GpuIncSubtensor,
-    GpuSubtensor,
-    GpuAdvancedSubtensor1,
-    GpuAdvancedSubtensor,
     GpuAdvancedIncSubtensor,
     GpuAdvancedIncSubtensor1,
     GpuAdvancedIncSubtensor1_dev20,
-    GpuExtractDiag,
+    GpuAdvancedSubtensor,
+    GpuAdvancedSubtensor1,
     GpuAllocDiag,
+    GpuExtractDiag,
+    GpuIncSubtensor,
+    GpuSubtensor,
 )
 from theano.gpuarray.type import gpuarray_shared_constructor
 
-from tests import unittest_tools as utt
-from tests.tensor.test_subtensor import TestSubtensor, TestAdvancedSubtensor
-from tests.tensor.test_basic import TestAllocDiag
-from tests.gpuarray.config import mode_with_gpu, test_ctx_name
-
 
 class TestGPUSubtensor(TestSubtensor):
     def setup_method(self):

tests/gpuarray/test_type.py

 import os
-import pytest
+
 import numpy as np
+import pytest
+
 import theano
 
+
 pygpu = pytest.importorskip("pygpu")
 
 from pickle import Unpickler
 
+from tests.gpuarray.config import test_ctx_name
+from tests.gpuarray.test_basic_ops import rand_gpuarray
 from theano import config
 from theano.compile import DeepCopyOp, Rebroadcast, ViewOp
 from theano.gpuarray.type import GpuArrayType, gpuarray_shared_constructor
 
-from tests.gpuarray.config import test_ctx_name
-from tests.gpuarray.test_basic_ops import rand_gpuarray
 
 # Disabled for now
 # from tests.tensor.test_sharedvar import makeSharedTester