Import sorting using isort

pystencils/stencil.py

 """This submodule offers functions to work with stencils in expression an offset-list form."""
+from collections import defaultdict
 from typing import Sequence
+
 import numpy as np
 import sympy as sp
-from collections import defaultdict
 
 
 def inverse_direction(direction):
@@ -91,7 +92,7 @@ def coefficient_dict(expr):
         >>> sorted(coeffs.items())
         [((-1, 0), 3), ((0, 1), 2)]
     """
-    from pystencils import Field
+    from pystencils.field import Field
     expr = expr.expand()
     field_accesses = expr.atoms(Field.Access)
     fields = set(fa.field for fa in field_accesses)

pystencils/sympyextensions.py

 import itertools
-import warnings
 import operator
-from functools import reduce, partial
-from collections import defaultdict, Counter
+import warnings
+from collections import Counter, defaultdict
+from functools import partial, reduce
+from typing import Callable, Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union
+
 import sympy as sp
 from sympy.functions import Abs
-from typing import Optional, Union, List, TypeVar, Iterable, Sequence, Callable, Dict, Tuple
-from pystencils.data_types import get_type_of_expression, get_base_type, cast_func
+
 from pystencils.assignment import Assignment
+from pystencils.data_types import cast_func, get_base_type, get_type_of_expression
 
 T = TypeVar('T')
 

pystencils/transformations.py

+import hashlib
+import pickle
 import warnings
-from collections import defaultdict, OrderedDict, namedtuple
+from collections import OrderedDict, defaultdict, namedtuple
 from copy import deepcopy
 from types import MappingProxyType
-import pickle
-import hashlib
+
 import sympy as sp
 from sympy.logic.boolalg import Boolean
-from pystencils.simp.assignment_collection import AssignmentCollection
+
+import pystencils.astnodes as ast
 from pystencils.assignment import Assignment
-from pystencils.field import AbstractField, FieldType, Field
-from pystencils.data_types import TypedSymbol, PointerType, StructType, get_base_type, reinterpret_cast_func, \
-    cast_func, pointer_arithmetic_func, get_type_of_expression, collate_types, create_type
+from pystencils.data_types import (
+    PointerType, StructType, TypedSymbol, cast_func, collate_types, create_type, get_base_type,
+    get_type_of_expression, pointer_arithmetic_func, reinterpret_cast_func)
+from pystencils.field import AbstractField, Field, FieldType
 from pystencils.kernelparameters import FieldPointerSymbol
+from pystencils.simp.assignment_collection import AssignmentCollection
 from pystencils.slicing import normalize_slice
-import pystencils.astnodes as ast
 
 
 class NestedScopes:

pystencils/utils.py

 import os
-from tempfile import NamedTemporaryFile
+from collections import Counter
 from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
 from typing import Mapping
-from collections import Counter
 
-import sympy as sp
 import numpy as np
+import sympy as sp
 
 
 class DotDict(dict):

pystencils_tests/benchmark/benchmark.py

-import os
 import math
+import os
 import time
+
 import numpy as np
 import sympy as sp
-from influxdb import InfluxDBClient
 from git import Repo
-from kerncraft.models import ECM, Benchmark, Roofline, RooflineIACA
+from influxdb import InfluxDBClient
 from kerncraft.machinemodel import MachineModel
+from kerncraft.models import ECM, Benchmark, Roofline, RooflineIACA
 from kerncraft.prefixedunit import PrefixedUnit
+
+from pystencils import Assignment, Field, create_kernel
 from pystencils.kerncraft_coupling import KerncraftParameters, PyStencilsKerncraftKernel
-from pystencils import Field, Assignment, create_kernel
 
 
 def output_benchmark(analysis):

pystencils_tests/benchmark/generate.py

-import sympy as sp
 import numpy as np
-from pystencils import Field, Assignment, create_kernel
+import sympy as sp
+
+from pystencils import Assignment, Field, create_kernel
 
 
 def meassure():
@@ -47,5 +48,3 @@ def meassure():
 
 if __name__ == "__main__":
     meassure()
-
-

pystencils_tests/test_address_of.py

@@ -3,10 +3,11 @@
 Test of pystencils.data_types.address_of
 """
 
-from pystencils.data_types import address_of, cast_func, PointerType
+import sympy
+
 import pystencils
+from pystencils.data_types import PointerType, address_of, cast_func
 from pystencils.simp.simplifications import sympy_cse
-import sympy
 
 
 def test_address_of():

pystencils_tests/test_assignment_collection.py

 import sympy as sp
+
 from pystencils import Assignment, AssignmentCollection
 from pystencils.simp.assignment_collection import SymbolGen
 

pystencils_tests/test_assignment_from_stencil.py

-import pystencils
 import numpy as np
 
+import pystencils
+
 
 def test_assignment_from_stencil():
 

pystencils_tests/test_blocking.py

-import sympy as sp
 import numpy as np
+import sympy as sp
+
 import pystencils as ps
 
 
@@ -58,4 +59,3 @@ def test_jacobi3d_fixed_size():
     arr = np.empty([8*4, 16*2, 4*3])
     src, dst = ps.fields("src, dst: double[3D]", src=arr, dst=arr)
     check_equivalence(jacobi(dst, src), arr)
-

pystencils_tests/test_blocking_staggered.py

 import numpy as np
+
 import pystencils as ps
 
 

pystencils_tests/test_boundary.py

-from tempfile import TemporaryDirectory
 import os
+from tempfile import TemporaryDirectory
+
 import numpy as np
 
-from pystencils import create_kernel, Assignment
-from pystencils.boundaries import add_neumann_boundary, Neumann, BoundaryHandling
+from pystencils import Assignment, create_kernel
+from pystencils.boundaries import BoundaryHandling, Neumann, add_neumann_boundary
 from pystencils.datahandling import SerialDataHandling
 from pystencils.slicing import slice_from_direction
 

pystencils_tests/test_buffer.py

 """Tests  (un)packing (from)to buffers."""
 
 import numpy as np
-from pystencils import Field, FieldType, Assignment, create_kernel
-from pystencils.field import layout_string_to_tuple, create_numpy_array_with_layout
-from pystencils.stencil import direction_string_to_offset
-from pystencils.slicing import add_ghost_layers, get_slice_before_ghost_layer, get_ghost_region_slice
 
+from pystencils import Assignment, Field, FieldType, create_kernel
+from pystencils.field import create_numpy_array_with_layout, layout_string_to_tuple
+from pystencils.slicing import (
+    add_ghost_layers, get_ghost_region_slice, get_slice_before_ghost_layer)
+from pystencils.stencil import direction_string_to_offset
 
 FIELD_SIZES = [(32, 10), (10, 8, 6)]
 

pystencils_tests/test_buffer_gpu.py

 """Tests for the (un)packing (from)to buffers on a CUDA GPU."""
 
 import numpy as np
-from pystencils import Field, FieldType, Assignment
-from pystencils.field import layout_string_to_tuple, create_numpy_array_with_layout
-from pystencils.stencil import direction_string_to_offset
-from pystencils.gpucuda import make_python_function, create_cuda_kernel
-from pystencils.slicing import add_ghost_layers, get_slice_before_ghost_layer, get_ghost_region_slice
 import pytest
+
+from pystencils import Assignment, Field, FieldType
+from pystencils.field import create_numpy_array_with_layout, layout_string_to_tuple
+from pystencils.gpucuda import create_cuda_kernel, make_python_function
+from pystencils.slicing import (
+    add_ghost_layers, get_ghost_region_slice, get_slice_before_ghost_layer)
+from pystencils.stencil import direction_string_to_offset
+
 try:
     # noinspection PyUnresolvedReferences
     import pycuda.autoinit

pystencils_tests/test_conditional_vec.py

-import pystencils as ps
-import sympy as sp
 import numpy as np
-from pystencils.astnodes import Conditional, Block
+import sympy as sp
+
+import pystencils as ps
+from pystencils.astnodes import Block, Conditional
 from pystencils.cpu.vectorization import vec_all, vec_any
 
 

pystencils_tests/test_cudagpu.py

 import numpy as np
-import sympy as sp
-from pystencils import Field, Assignment, fields
-from pystencils.simp import sympy_cse_on_assignment_list
-from pystencils.gpucuda.indexing import LineIndexing
-from pystencils.slicing import remove_ghost_layers, add_ghost_layers, make_slice
-from pystencils.gpucuda import make_python_function, create_cuda_kernel, BlockIndexing
 import pycuda.gpuarray as gpuarray
+import sympy as sp
 from scipy.ndimage import convolve
 
+from pystencils import Assignment, Field, fields
+from pystencils.gpucuda import BlockIndexing, create_cuda_kernel, make_python_function
+from pystencils.gpucuda.indexing import LineIndexing
+from pystencils.simp import sympy_cse_on_assignment_list
+from pystencils.slicing import add_ghost_layers, make_slice, remove_ghost_layers
+
 
 def test_averaging_kernel():
     size = (40, 55)

pystencils_tests/test_datahandling.py

-import numpy as np
 import os
 from tempfile import TemporaryDirectory
+
+import numpy as np
+
 import pystencils as ps
-from pystencils import create_kernel, create_data_handling
+from pystencils import create_data_handling, create_kernel
 
 
 def basic_iteration(dh):

pystencils_tests/test_datahandling_parallel.py

 import numpy as np
-from pystencils.datahandling.parallel_datahandling import ParallelDataHandling
-from pystencils_tests.test_datahandling import access_and_gather, synchronization, kernel_execution_jacobi, vtk_output, \
-    reduction
 import waLBerla as wlb
 
+from pystencils.datahandling.parallel_datahandling import ParallelDataHandling
+from pystencils_tests.test_datahandling import (
+    access_and_gather, kernel_execution_jacobi, reduction, synchronization, vtk_output)
+
 
 def test_access_and_gather():
     block_size = (4, 7, 1)

pystencils_tests/test_derivative.py

 import sympy as sp
-import pystencils as ps
+from sympy.abc import a, b, t, x, y, z
 from sympy.printing.latex import LatexPrinter
+
+import pystencils as ps
 from pystencils.fd import *
-from sympy.abc import a, b, t, x, y, z
 
 
 def test_derivative_basic():

pystencils_tests/test_dtype_check.py

-import pystencils
 import numpy as np
 import pytest
 
+import pystencils
+
 
 def test_dtype_check_wrong_type():
     array = np.ones((10, 20)).astype(np.float32)