diff --git a/.isort.cfg b/.isort.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..cbdece3111e9f53cddffe209dd5e1ac4930ad9c5
--- /dev/null
+++ b/.isort.cfg
@@ -0,0 +1,4 @@
+[settings]
+line_length=100
+balanced_wrapping=True
+multi_line_output=4
diff --git a/conftest.py b/conftest.py
index 5a7ce065a9888d02faf36c9d9f3c3c279dce865d..1502422ee5245b5cbcd8dad216e4ef68b36f97d1 100644
--- a/conftest.py
+++ b/conftest.py
@@ -89,6 +89,7 @@ class IPyNbTest(pytest.Item):
         self.code = code
         self.add_marker('notebook')
 
+    @pytest.mark.filterwarnings("ignore:IPython.core.inputsplitter is deprecated")
     def runtest(self):
         global_dict = {'get_ipython': lambda: IPythonMockup(),
                        'is_test_run': True}
diff --git a/pystencils/__init__.py b/pystencils/__init__.py
index 8095205da7bd50b610f299d096916524b1a787f1..a7e21703b48c7398da8be6f609f0f3123f7822d1 100644
--- a/pystencils/__init__.py
+++ b/pystencils/__init__.py
@@ -1,18 +1,17 @@
 """Module to generate stencil kernels in C or CUDA using sympy expressions and call them as Python functions"""
 from . import sympy_gmpy_bug_workaround  # NOQA
-from .field import Field, FieldType, fields
+from . import fd
+from . import stencil as stencil
+from .assignment import Assignment, assignment_from_stencil
 from .data_types import TypedSymbol
-from .slicing import make_slice
-from .kernelcreation import create_kernel, create_indexed_kernel, create_staggered_kernel
+from .datahandling import create_data_handling
 from .display_utils import show_code, to_dot
+from .field import Field, FieldType, fields
+from .kernel_decorator import kernel
+from .kernelcreation import create_indexed_kernel, create_kernel, create_staggered_kernel
 from .simp import AssignmentCollection
-from .assignment import Assignment, assignment_from_stencil
+from .slicing import make_slice
 from .sympyextensions import SymbolCreator
-from .datahandling import create_data_handling
-from .kernel_decorator import kernel
-from . import fd
-from . import stencil as stencil
-
 
 __all__ = ['Field', 'FieldType', 'fields',
            'TypedSymbol',
diff --git a/pystencils/assignment.py b/pystencils/assignment.py
index 757413abd5e8555c47f6343a7553ac64b0a40dc7..45a95d41ecd643618a3d3b6b4a8a9aa0455a2a02 100644
--- a/pystencils/assignment.py
+++ b/pystencils/assignment.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import numpy as np
 import sympy as sp
 from sympy.printing.latex import LatexPrinter
 
@@ -6,7 +7,6 @@ try:
     from sympy.codegen.ast import Assignment
 except ImportError:
     Assignment = None
-import numpy as np
 
 __all__ = ['Assignment', 'assignment_from_stencil']
 
@@ -84,7 +84,7 @@ def assignment_from_stencil(stencil_array, input_field, output_field,
         >>> assignment_from_stencil(stencil, f[1, 0], g[2, 0])
         Assignment(g_2E, 3*f_C + 6*f_SE + 4*f_E + 2*f_NE + 5*f_2E)
     """
-    from pystencils import Field
+    from pystencils.field import Field
 
     stencil_array = np.array(stencil_array)
     if order == 'visual':
diff --git a/pystencils/astnodes.py b/pystencils/astnodes.py
index d83c488d068d9058e2c0e3c3e9d34454272d32b2..441de76aa9b2c7a771ceba7ba4010e67023ac9e7 100644
--- a/pystencils/astnodes.py
+++ b/pystencils/astnodes.py
@@ -5,8 +5,7 @@ import sympy as sp
 
 from pystencils.data_types import TypedSymbol, cast_func, create_type
 from pystencils.field import Field
-from pystencils.kernelparameters import (FieldPointerSymbol, FieldShapeSymbol,
-                                         FieldStrideSymbol)
+from pystencils.kernelparameters import FieldPointerSymbol, FieldShapeSymbol, FieldStrideSymbol
 from pystencils.sympyextensions import fast_subs
 
 NodeOrExpr = Union['Node', sp.Expr]
diff --git a/pystencils/backends/cbackend.py b/pystencils/backends/cbackend.py
index 7c4937d1f524fdd76299a0f86b97bae4377eab16..bb621f8037e561115e132ceede66491e6c581a25 100644
--- a/pystencils/backends/cbackend.py
+++ b/pystencils/backends/cbackend.py
@@ -6,18 +6,15 @@ import sympy as sp
 from sympy.core import S
 from sympy.printing.ccode import C89CodePrinter
 
-from pystencils.astnodes import (DestructuringBindingsForFieldClass,
-                                 KernelFunction, Node)
+from pystencils.astnodes import DestructuringBindingsForFieldClass, KernelFunction, Node
 from pystencils.cpu.vectorization import vec_all, vec_any
-from pystencils.data_types import (PointerType, VectorType, address_of,
-                                   cast_func, create_type,
-                                   get_type_of_expression,
-                                   reinterpret_cast_func, vector_memory_access)
-from pystencils.fast_approximation import (fast_division, fast_inv_sqrt,
-                                           fast_sqrt)
-from pystencils.integer_functions import (bit_shift_left, bit_shift_right,
-                                          bitwise_and, bitwise_or, bitwise_xor,
-                                          int_div, int_power_of_2, modulo_ceil)
+from pystencils.data_types import (
+    PointerType, VectorType, address_of, cast_func, create_type, get_type_of_expression,
+    reinterpret_cast_func, vector_memory_access)
+from pystencils.fast_approximation import fast_division, fast_inv_sqrt, fast_sqrt
+from pystencils.integer_functions import (
+    bit_shift_left, bit_shift_right, bitwise_and, bitwise_or, bitwise_xor,
+    int_div, int_power_of_2, modulo_ceil)
 from pystencils.kernelparameters import FieldPointerSymbol
 
 try:
diff --git a/pystencils/backends/dot.py b/pystencils/backends/dot.py
index bfec9cfdb2a7d9a32285b0a967b47980be78f907..64610c47af6148d6008780ba80530d678e518486 100644
--- a/pystencils/backends/dot.py
+++ b/pystencils/backends/dot.py
@@ -1,6 +1,6 @@
-from sympy.printing.printer import Printer
-from graphviz import Digraph, lang
 import graphviz
+from graphviz import Digraph, lang
+from sympy.printing.printer import Printer
 
 
 # noinspection PyPep8Naming
diff --git a/pystencils/boundaries/__init__.py b/pystencils/boundaries/__init__.py
index cf94f330fbf384d075886aca1abd8aaf05dc29f0..890ea208333197804ae8b44ee147b68113ed4d99 100644
--- a/pystencils/boundaries/__init__.py
+++ b/pystencils/boundaries/__init__.py
@@ -1,5 +1,5 @@
+from pystencils.boundaries.boundaryconditions import Dirichlet, Neumann
 from pystencils.boundaries.boundaryhandling import BoundaryHandling
-from pystencils.boundaries.boundaryconditions import Neumann, Dirichlet
 from pystencils.boundaries.inkernel import add_neumann_boundary
 
 __all__ = ['BoundaryHandling', 'Neumann', 'Dirichlet', 'add_neumann_boundary']
diff --git a/pystencils/boundaries/boundaryconditions.py b/pystencils/boundaries/boundaryconditions.py
index 10870c4cd5cd999b05fbc3dd72cb9de6710c25a6..39338634a51cae5bfc782efaae2ac69ca523152e 100644
--- a/pystencils/boundaries/boundaryconditions.py
+++ b/pystencils/boundaries/boundaryconditions.py
@@ -1,4 +1,5 @@
-from typing import List, Tuple, Any
+from typing import Any, List, Tuple
+
 from pystencils import Assignment
 from pystencils.boundaries.boundaryhandling import BoundaryOffsetInfo
 from pystencils.data_types import create_type
diff --git a/pystencils/boundaries/boundaryhandling.py b/pystencils/boundaries/boundaryhandling.py
index 384c10d4ff30b0ad983fac2dabd28a72df54a979..d258de4b3e5e7d5b85c69d0910ea384b77ecd110 100644
--- a/pystencils/boundaries/boundaryhandling.py
+++ b/pystencils/boundaries/boundaryhandling.py
@@ -1,11 +1,14 @@
 import numpy as np
 import sympy as sp
+
+from pystencils import create_indexed_kernel
 from pystencils.assignment import Assignment
-from pystencils import Field, TypedSymbol, create_indexed_kernel
 from pystencils.backends.cbackend import CustomCodeNode
-from pystencils.boundaries.createindexlist import numpy_data_type_for_boundary_object, create_boundary_index_array
+from pystencils.boundaries.createindexlist import (
+    create_boundary_index_array, numpy_data_type_for_boundary_object)
 from pystencils.cache import memorycache
-from pystencils.data_types import create_type
+from pystencils.data_types import TypedSymbol, create_type
+from pystencils.field import Field
 from pystencils.kernelparameters import FieldPointerSymbol
 
 DEFAULT_FLAG_TYPE = np.uint32
diff --git a/pystencils/boundaries/createindexlist.py b/pystencils/boundaries/createindexlist.py
index f3aff9c43bad7eb77b79e1202a65c04ab51c17d6..a0ee87f3b25960550d72a85a9a2ddf5cfca99ce7 100644
--- a/pystencils/boundaries/createindexlist.py
+++ b/pystencils/boundaries/createindexlist.py
@@ -1,7 +1,8 @@
-import numpy as np
 import itertools
 import warnings
 
+import numpy as np
+
 try:
     # Try to import right away - assume compiled code is available
     # compile with: python setup.py build_ext --inplace --use-cython
diff --git a/pystencils/boundaries/inkernel.py b/pystencils/boundaries/inkernel.py
index 73da40beefc81826430fdcf67fec5c0b5beb98c8..1d78814db6fadcc8a161353638f4dc61be36c0e4 100644
--- a/pystencils/boundaries/inkernel.py
+++ b/pystencils/boundaries/inkernel.py
@@ -1,21 +1,26 @@
 import sympy as sp
-from pystencils import Field, TypedSymbol
-from pystencils.integer_functions import bitwise_and
+
 from pystencils.boundaries.boundaryhandling import DEFAULT_FLAG_TYPE
-from pystencils.data_types import create_type
+from pystencils.data_types import TypedSymbol, create_type
+from pystencils.field import Field
+from pystencils.integer_functions import bitwise_and
 
 
 def add_neumann_boundary(eqs, fields, flag_field, boundary_flag="neumann_flag", inverse_flag=False):
     """
     Replaces all neighbor accesses by flag field guarded accesses.
     If flag in neighboring cell is set, the center value is used instead
-    :param eqs: list of equations containing field accesses to direct neighbors
-    :param fields: fields for which the Neumann boundary should be applied
-    :param flag_field: integer field marking boundary cells
-    :param boundary_flag: if flag field has value 'boundary_flag' (no bit operations yet)
-                          the cell is assumed to be boundary
-    :param inverse_flag: if true, boundary cells are where flag field has not the value of boundary_flag
-    :return: list of equations with guarded field accesses
+
+    Args:
+        eqs: list of equations containing field accesses to direct neighbors
+        fields: fields for which the Neumann boundary should be applied
+        flag_field: integer field marking boundary cells
+        boundary_flag: if flag field has value 'boundary_flag' (no bit operations yet)
+                       the cell is assumed to be boundary
+        inverse_flag: if true, boundary cells are where flag field has not the value of boundary_flag
+
+    Returns:
+        list of equations with guarded field accesses
     """
     if not hasattr(fields, "__len__"):
         fields = [fields]
diff --git a/pystencils/cpu/__init__.py b/pystencils/cpu/__init__.py
index 900a32eab83e3fc1ae5fe88553d98d75d802b679..e15bc8cf0b2a33eaa486c8e95e3cb50404cfa5e6 100644
--- a/pystencils/cpu/__init__.py
+++ b/pystencils/cpu/__init__.py
@@ -1,4 +1,4 @@
-from pystencils.cpu.kernelcreation import create_kernel, create_indexed_kernel, add_openmp
 from pystencils.cpu.cpujit import make_python_function
+from pystencils.cpu.kernelcreation import add_openmp, create_indexed_kernel, create_kernel
 
 __all__ = ['create_kernel', 'create_indexed_kernel', 'add_openmp', 'make_python_function']
diff --git a/pystencils/cpu/cpujit.py b/pystencils/cpu/cpujit.py
index 09128360d5c00bd97747a3039ce03572c169486a..c2561c1496add7426b24f1b153c04fe9340d494b 100644
--- a/pystencils/cpu/cpujit.py
+++ b/pystencils/cpu/cpujit.py
@@ -43,25 +43,24 @@ Then 'cl.exe' is used to compile.
   For Windows compilers the qualifier should be ``__restrict``
 
 """
-import os
 import hashlib
 import json
+import os
 import platform
 import shutil
+import subprocess
 import textwrap
+from collections import OrderedDict
+from sysconfig import get_paths
 from tempfile import TemporaryDirectory
 
 import numpy as np
-import subprocess
-from appdirs import user_config_dir, user_cache_dir
-from collections import OrderedDict
+from appdirs import user_cache_dir, user_config_dir
 
-from pystencils.utils import recursive_dict_update
-from sysconfig import get_paths
-from pystencils import FieldType
 from pystencils.backends.cbackend import generate_c, get_headers
-from pystencils.utils import file_handle_for_atomic_write, atomic_file_write
+from pystencils.field import FieldType
 from pystencils.include import get_pystencils_include_path
+from pystencils.utils import atomic_file_write, file_handle_for_atomic_write, recursive_dict_update
 
 
 def make_python_function(kernel_function_node):
diff --git a/pystencils/cpu/kernelcreation.py b/pystencils/cpu/kernelcreation.py
index d3b791901b4b04a0b9bfb94f7308a5dc74ba6c61..fc6765e589e341b40ebbc778c7c26839531ae826 100644
--- a/pystencils/cpu/kernelcreation.py
+++ b/pystencils/cpu/kernelcreation.py
@@ -1,14 +1,17 @@
+from typing import List, Union
+
 import sympy as sp
-from pystencils.astnodes import SympyAssignment, Block, LoopOverCoordinate, KernelFunction
-from pystencils.transformations import resolve_buffer_accesses, resolve_field_accesses, make_loop_over_domain, \
-    add_types, get_optimal_loop_ordering, parse_base_pointer_info, move_constants_before_loop, \
-    split_inner_loop, get_base_buffer_index, filtered_tree_iteration
-from pystencils.data_types import TypedSymbol, BasicType, StructType, create_type
-from pystencils.field import Field, FieldType
+
 import pystencils.astnodes as ast
-from pystencils.cpu.cpujit import make_python_function
 from pystencils.assignment import Assignment
-from typing import List, Union
+from pystencils.astnodes import Block, KernelFunction, LoopOverCoordinate, SympyAssignment
+from pystencils.cpu.cpujit import make_python_function
+from pystencils.data_types import BasicType, StructType, TypedSymbol, create_type
+from pystencils.field import Field, FieldType
+from pystencils.transformations import (
+    add_types, filtered_tree_iteration, get_base_buffer_index, get_optimal_loop_ordering,
+    make_loop_over_domain, move_constants_before_loop, parse_base_pointer_info,
+    resolve_buffer_accesses, resolve_field_accesses, split_inner_loop)
 
 AssignmentOrAstNodeList = List[Union[Assignment, ast.Node]]
 
diff --git a/pystencils/cpu/msvc_detection.py b/pystencils/cpu/msvc_detection.py
index be0fb9189ae3d4516472ec1f76da6b15284847a3..94b2bcf5bc978c70c083ab3c2d0a6a6e0b2aea62 100644
--- a/pystencils/cpu/msvc_detection.py
+++ b/pystencils/cpu/msvc_detection.py
@@ -1,5 +1,5 @@
-import subprocess
 import os
+import subprocess
 
 
 def get_environment(version_specifier, arch='x64'):
diff --git a/pystencils/cpu/vectorization.py b/pystencils/cpu/vectorization.py
index 619a55ad0edac4fbdac7c6cecfb1afd0125f5ac8..6bf3a26def2dba238eeb4c64e325a41d58fd2afa 100644
--- a/pystencils/cpu/vectorization.py
+++ b/pystencils/cpu/vectorization.py
@@ -1,15 +1,19 @@
-import sympy as sp
 import warnings
-from typing import Union, Container
-from pystencils.backends.simd_instruction_sets import get_vector_instruction_set
-from pystencils.fast_approximation import fast_division, fast_sqrt, fast_inv_sqrt
-from pystencils.integer_functions import modulo_floor, modulo_ceil
-from pystencils.sympyextensions import fast_subs
-from pystencils.data_types import TypedSymbol, VectorType, get_type_of_expression, vector_memory_access, cast_func, \
-    collate_types, PointerType
+from typing import Container, Union
+
+import sympy as sp
+
 import pystencils.astnodes as ast
-from pystencils.transformations import cut_loop, filtered_tree_iteration, replace_inner_stride_with_one
+from pystencils.backends.simd_instruction_sets import get_vector_instruction_set
+from pystencils.data_types import (
+    PointerType, TypedSymbol, VectorType, cast_func, collate_types, get_type_of_expression,
+    vector_memory_access)
+from pystencils.fast_approximation import fast_division, fast_inv_sqrt, fast_sqrt
 from pystencils.field import Field
+from pystencils.integer_functions import modulo_ceil, modulo_floor
+from pystencils.sympyextensions import fast_subs
+from pystencils.transformations import (
+    cut_loop, filtered_tree_iteration, replace_inner_stride_with_one)
 
 
 # noinspection PyPep8Naming
diff --git a/pystencils/data_types.py b/pystencils/data_types.py
index 3f1a02c6833756985308282c49148fe0ecaa0153..8bf28e777e9bf9deec30f21cafe8cb3b7ac77b17 100644
--- a/pystencils/data_types.py
+++ b/pystencils/data_types.py
@@ -1,17 +1,18 @@
 import ctypes
-import sympy as sp
+
 import numpy as np
+import sympy as sp
+from sympy.core.cache import cacheit
+from sympy.logic.boolalg import Boolean
+
+from pystencils.cache import memorycache
+from pystencils.utils import all_equal
 
 try:
     import llvmlite.ir as ir
 except ImportError as e:
     ir = None
     _ir_importerror = e
-from sympy.core.cache import cacheit
-
-from pystencils.cache import memorycache
-from pystencils.utils import all_equal
-from sympy.logic.boolalg import Boolean
 
 
 # noinspection PyPep8Naming
diff --git a/pystencils/datahandling/__init__.py b/pystencils/datahandling/__init__.py
index 5b617bf4972835e4c25ed11d92d47e5a8de83da5..583f121b09ffbfdc6dc2103ec6e300e639791891 100644
--- a/pystencils/datahandling/__init__.py
+++ b/pystencils/datahandling/__init__.py
@@ -1,6 +1,7 @@
 from typing import Tuple, Union
-from .serial_datahandling import SerialDataHandling
+
 from .datahandling_interface import DataHandling
+from .serial_datahandling import SerialDataHandling
 
 try:
     # noinspection PyPep8Naming
diff --git a/pystencils/datahandling/blockiteration.py b/pystencils/datahandling/blockiteration.py
index 04297087bf6147dc885a060a2c25ecbc6013e8bc..fdf2b97e8f677db586e28c61ca66c08f9426c708 100644
--- a/pystencils/datahandling/blockiteration.py
+++ b/pystencils/datahandling/blockiteration.py
@@ -7,6 +7,7 @@ import numpy as np
 
 from pystencils.datahandling.datahandling_interface import Block
 from pystencils.slicing import normalize_slice
+
 try:
     # noinspection PyPep8Naming
     import waLBerla as wlb
diff --git a/pystencils/datahandling/datahandling_interface.py b/pystencils/datahandling/datahandling_interface.py
index da2108bfbdbdc3d09abfc4b6a55cda1c1850b63c..ce153ff7a95e6a3e2875aa5b02566874c3238662 100644
--- a/pystencils/datahandling/datahandling_interface.py
+++ b/pystencils/datahandling/datahandling_interface.py
@@ -1,6 +1,8 @@
-import numpy as np
 from abc import ABC, abstractmethod
-from typing import Optional, Callable, Sequence, Iterable, Tuple, Dict, Union
+from typing import Callable, Dict, Iterable, Optional, Sequence, Tuple, Union
+
+import numpy as np
+
 from pystencils.field import Field
 
 
diff --git a/pystencils/datahandling/parallel_datahandling.py b/pystencils/datahandling/parallel_datahandling.py
index 31ca00e2cde997490a8010010e70b96ca2ec9963..4e8d965d4335725e5e0a00b842bbffeab9497924 100644
--- a/pystencils/datahandling/parallel_datahandling.py
+++ b/pystencils/datahandling/parallel_datahandling.py
@@ -1,13 +1,15 @@
 import os
-import numpy as np
 import warnings
-from pystencils import Field
+
+import numpy as np
+# noinspection PyPep8Naming
+import waLBerla as wlb
+
+from pystencils.datahandling.blockiteration import block_iteration, sliced_block_iteration
 from pystencils.datahandling.datahandling_interface import DataHandling
-from pystencils.datahandling.blockiteration import sliced_block_iteration, block_iteration
+from pystencils.field import Field
 from pystencils.kernelparameters import FieldPointerSymbol
 from pystencils.utils import DotDict
-# noinspection PyPep8Naming
-import waLBerla as wlb
 
 
 class ParallelDataHandling(DataHandling):
diff --git a/pystencils/datahandling/serial_datahandling.py b/pystencils/datahandling/serial_datahandling.py
index 7e4d19cd8e24aa485a48893d4c992d34078a0f13..8c79a0931f06fad7c7ab58143cf7058a3f52dbac 100644
--- a/pystencils/datahandling/serial_datahandling.py
+++ b/pystencils/datahandling/serial_datahandling.py
@@ -1,11 +1,13 @@
 import itertools
+import time
 from typing import Sequence, Union
+
 import numpy as np
-import time
-from pystencils import Field
-from pystencils.datahandling.datahandling_interface import DataHandling
-from pystencils.field import layout_string_to_tuple, spatial_layout_string_to_tuple, create_numpy_array_with_layout
+
 from pystencils.datahandling.blockiteration import SerialBlock
+from pystencils.datahandling.datahandling_interface import DataHandling
+from pystencils.field import (
+    Field, create_numpy_array_with_layout, layout_string_to_tuple, spatial_layout_string_to_tuple)
 from pystencils.slicing import normalize_slice, remove_ghost_layers
 from pystencils.utils import DotDict
 
diff --git a/pystencils/datahandling/vtk.py b/pystencils/datahandling/vtk.py
index dcdf2d2d07f9a54c2fd519a5fcbcedf43e33218f..9c5f27fa88961673b1707fcb354b7771d091bb91 100644
--- a/pystencils/datahandling/vtk.py
+++ b/pystencils/datahandling/vtk.py
@@ -1,5 +1,5 @@
-from pyevtk.vtk import VtkFile, VtkImageData
 from pyevtk.hl import _addDataToFile, _appendDataToFile
+from pyevtk.vtk import VtkFile, VtkImageData
 
 
 def image_to_vtk(path, cell_data, origin=(0.0, 0.0, 0.0), spacing=(1.0, 1.0, 1.0)):
diff --git a/pystencils/display_utils.py b/pystencils/display_utils.py
index 55a4720c194e250cd549279ae76607c48968c676..77eca2e86034d2ab86ea1d506ac367c761ea3b0f 100644
--- a/pystencils/display_utils.py
+++ b/pystencils/display_utils.py
@@ -1,5 +1,7 @@
-import sympy as sp
 from typing import Any, Dict, Optional
+
+import sympy as sp
+
 from pystencils.astnodes import KernelFunction
 
 
diff --git a/pystencils/fast_approximation.py b/pystencils/fast_approximation.py
index 0dbdab241151a5e211efa0c9a4847fcbd9211fae..f33009600c9dd57a89ca63695063237792b6d8d1 100644
--- a/pystencils/fast_approximation.py
+++ b/pystencils/fast_approximation.py
@@ -1,6 +1,7 @@
-import sympy as sp
 from typing import List, Union
 
+import sympy as sp
+
 from pystencils.astnodes import Node
 from pystencils.simp import AssignmentCollection
 
diff --git a/pystencils/fd/__init__.py b/pystencils/fd/__init__.py
index 62b11e4e79f6abe60d0352fb7e3888b02774a0f9..0997634114077a5e105d717b1fbe570e34e9158a 100644
--- a/pystencils/fd/__init__.py
+++ b/pystencils/fd/__init__.py
@@ -1,8 +1,8 @@
-from .derivative import Diff, DiffOperator, \
-    diff_terms, collect_diffs, zero_diffs, evaluate_diffs, normalize_diff_order, \
-    expand_diff_full, expand_diff_linear, expand_diff_products, combine_diff_products, \
-    functional_derivative, diff
-from .finitedifferences import advection, diffusion, transient, Discretization2ndOrder
+from .derivative import (
+    Diff, DiffOperator, collect_diffs, combine_diff_products, diff, diff_terms, evaluate_diffs,
+    expand_diff_full, expand_diff_linear, expand_diff_products, functional_derivative,
+    normalize_diff_order, zero_diffs)
+from .finitedifferences import Discretization2ndOrder, advection, diffusion, transient
 from .spatial import discretize_spatial, discretize_spatial_staggered
 
 __all__ = ['Diff', 'diff', 'DiffOperator', 'diff_terms', 'collect_diffs',
diff --git a/pystencils/fd/derivation.py b/pystencils/fd/derivation.py
index 0d0d1e08dedc8622d0ec343124d6adf481454fc3..451648ef334a553aa0a13d6b3a6d9a7bab7779c9 100644
--- a/pystencils/fd/derivation.py
+++ b/pystencils/fd/derivation.py
@@ -1,8 +1,10 @@
-import sympy as sp
 from collections import defaultdict
+
+import sympy as sp
+
 from pystencils.field import Field
-from pystencils.sympyextensions import prod, multidimensional_sum
-from pystencils.utils import fully_contains, LinearEquationSystem
+from pystencils.sympyextensions import multidimensional_sum, prod
+from pystencils.utils import LinearEquationSystem, fully_contains
 
 
 class FiniteDifferenceStencilDerivation:
diff --git a/pystencils/fd/derivative.py b/pystencils/fd/derivative.py
index 0557a2d503699fc9a336c1b42594e0638676df55..7acd245059615ded27e2c1fe023e344b48c34a6e 100644
--- a/pystencils/fd/derivative.py
+++ b/pystencils/fd/derivative.py
@@ -1,6 +1,8 @@
+from collections import defaultdict, namedtuple
+
 import sympy as sp
-from collections import namedtuple, defaultdict
-from pystencils import Field
+
+from pystencils.field import Field
 from pystencils.sympyextensions import normalize_product, prod
 
 
diff --git a/pystencils/fd/finitedifferences.py b/pystencils/fd/finitedifferences.py
index 3cb7e6db7054953c348ff163300f2d6d6d07ff21..d5bce66e96d8aa5d296df68906c8871d40c08bba 100644
--- a/pystencils/fd/finitedifferences.py
+++ b/pystencils/fd/finitedifferences.py
@@ -1,14 +1,15 @@
+from typing import Optional, Union
+
 import numpy as np
 import sympy as sp
-from typing import Union, Optional
 
-from pystencils import Field, AssignmentCollection
 from pystencils.fd import Diff
 from pystencils.fd.derivative import diff_args
 from pystencils.fd.spatial import fd_stencils_standard
+from pystencils.field import Field
+from pystencils.simp.assignment_collection import AssignmentCollection
 from pystencils.sympyextensions import fast_subs
 
-
 FieldOrFieldAccess = Union[Field, Field.Access]
 
 
diff --git a/pystencils/fd/spatial.py b/pystencils/fd/spatial.py
index 0f9ba7571c2c7b1a9d4b9965490e02151d91a55e..fda6773ce48314416c14bf2381614b95cf413d03 100644
--- a/pystencils/fd/spatial.py
+++ b/pystencils/fd/spatial.py
@@ -1,12 +1,15 @@
 from typing import Tuple
+
 import sympy as sp
+
 from pystencils.astnodes import LoopOverCoordinate
 from pystencils.cache import memorycache
-from pystencils import Field
 from pystencils.fd import Diff
+from pystencils.field import Field
 from pystencils.transformations import generic_visit
-from .derivative import diff_args
+
 from .derivation import FiniteDifferenceStencilDerivation
+from .derivative import diff_args
 
 
 def fd_stencils_standard(indices, dx, fa):
diff --git a/pystencils/field.py b/pystencils/field.py
index 0c3af6dfa4edec15cb0f1cdff4822083eaacc017..5fa456c68f6b8dd4799ea7c73f346885da9814f4 100644
--- a/pystencils/field.py
+++ b/pystencils/field.py
@@ -1,17 +1,19 @@
+import hashlib
+import pickle
+import re
 from enum import Enum
 from itertools import chain
-from typing import Tuple, Sequence, Optional, List, Set
+from typing import List, Optional, Sequence, Set, Tuple
+
 import numpy as np
 import sympy as sp
-import re
 from sympy.core.cache import cacheit
+
 from pystencils.alignedarray import aligned_empty
-from pystencils.data_types import create_type, StructType
+from pystencils.data_types import StructType, create_type
 from pystencils.kernelparameters import FieldShapeSymbol, FieldStrideSymbol
-from pystencils.stencil import offset_to_direction_string, direction_string_to_offset
+from pystencils.stencil import direction_string_to_offset, offset_to_direction_string
 from pystencils.sympyextensions import is_integer_sequence
-import pickle
-import hashlib
 
 __all__ = ['Field', 'fields', 'FieldType', 'AbstractField']
 
diff --git a/pystencils/gpucuda/__init__.py b/pystencils/gpucuda/__init__.py
index 9b178c47023963ee47110d49cf83e93ba6a94420..e7be5452768f059dffdadf5a375f1dfce036efc9 100644
--- a/pystencils/gpucuda/__init__.py
+++ b/pystencils/gpucuda/__init__.py
@@ -1,5 +1,7 @@
-from pystencils.gpucuda.kernelcreation import create_cuda_kernel, created_indexed_cuda_kernel
 from pystencils.gpucuda.cudajit import make_python_function
+from pystencils.gpucuda.kernelcreation import create_cuda_kernel, created_indexed_cuda_kernel
+
 from .indexing import AbstractIndexing, BlockIndexing, LineIndexing
+
 __all__ = ['create_cuda_kernel', 'created_indexed_cuda_kernel', 'make_python_function',
            'AbstractIndexing', 'BlockIndexing', 'LineIndexing']
diff --git a/pystencils/gpucuda/cudajit.py b/pystencils/gpucuda/cudajit.py
index 90c23b133eba1a5e60e8ecfa80a0a849e2b3ab19..40dbfda8fc9e125d291b71a8c134f111b9d16b89 100644
--- a/pystencils/gpucuda/cudajit.py
+++ b/pystencils/gpucuda/cudajit.py
@@ -1,10 +1,10 @@
 import numpy as np
+
 from pystencils.backends.cbackend import generate_c, get_headers
-from pystencils.kernelparameters import FieldPointerSymbol
 from pystencils.data_types import StructType
 from pystencils.field import FieldType
 from pystencils.include import get_pystencils_include_path
-
+from pystencils.kernelparameters import FieldPointerSymbol
 
 USE_FAST_MATH = True
 
diff --git a/pystencils/gpucuda/indexing.py b/pystencils/gpucuda/indexing.py
index 5864c4f82bd488b2ac2844faf45210a620efe09a..f6f1fbe80c3da6c1dea78cf687fe96dc6810ec10 100644
--- a/pystencils/gpucuda/indexing.py
+++ b/pystencils/gpucuda/indexing.py
@@ -1,13 +1,14 @@
 import abc
+from functools import partial
 from typing import Tuple  # noqa
+
 import sympy as sp
-from pystencils.astnodes import Conditional, Block
+
+from pystencils.astnodes import Block, Conditional
+from pystencils.data_types import TypedSymbol, create_type
 from pystencils.integer_functions import div_ceil, div_floor
 from pystencils.slicing import normalize_slice
-from pystencils.data_types import TypedSymbol, create_type
-from functools import partial
-
-from pystencils.sympyextensions import prod, is_integer_sequence
+from pystencils.sympyextensions import is_integer_sequence, prod
 
 BLOCK_IDX = [TypedSymbol("blockIdx." + coord, create_type("int")) for coord in ('x', 'y', 'z')]
 THREAD_IDX = [TypedSymbol("threadIdx." + coord, create_type("int")) for coord in ('x', 'y', 'z')]
diff --git a/pystencils/gpucuda/kernelcreation.py b/pystencils/gpucuda/kernelcreation.py
index fd387efbd529220686647acf2235ca90cfe9dc56..bc6de8d3a1982437bc236bfea6b8298d995caa4c 100644
--- a/pystencils/gpucuda/kernelcreation.py
+++ b/pystencils/gpucuda/kernelcreation.py
@@ -1,10 +1,11 @@
-from pystencils.gpucuda.indexing import BlockIndexing
-from pystencils.transformations import resolve_field_accesses, add_types, parse_base_pointer_info, \
-    get_common_shape, resolve_buffer_accesses, unify_shape_symbols, get_base_buffer_index
-from pystencils.astnodes import Block, KernelFunction, SympyAssignment, LoopOverCoordinate
-from pystencils.data_types import TypedSymbol, BasicType, StructType
-from pystencils import Field, FieldType
+from pystencils.astnodes import Block, KernelFunction, LoopOverCoordinate, SympyAssignment
+from pystencils.data_types import BasicType, StructType, TypedSymbol
+from pystencils.field import Field, FieldType
 from pystencils.gpucuda.cudajit import make_python_function
+from pystencils.gpucuda.indexing import BlockIndexing
+from pystencils.transformations import (
+    add_types, get_base_buffer_index, get_common_shape, parse_base_pointer_info,
+    resolve_buffer_accesses, resolve_field_accesses, unify_shape_symbols)
 
 
 def create_cuda_kernel(assignments, function_name="kernel", type_info=None, indexing_creator=BlockIndexing,
diff --git a/pystencils/gpucuda/periodicity.py b/pystencils/gpucuda/periodicity.py
index 5657d4618623b421c0d3ef25a60774085d85bb32..e94a1796e3a66da626fc4e13fcc0413f5f93961d 100644
--- a/pystencils/gpucuda/periodicity.py
+++ b/pystencils/gpucuda/periodicity.py
@@ -1,8 +1,9 @@
 import numpy as np
-from pystencils import Field, Assignment
-from pystencils.slicing import normalize_slice, get_periodic_boundary_src_dst_slices
+
+from pystencils import Assignment, Field
 from pystencils.gpucuda import make_python_function
 from pystencils.gpucuda.kernelcreation import create_cuda_kernel
+from pystencils.slicing import get_periodic_boundary_src_dst_slices, normalize_slice
 
 
 def create_copy_kernel(domain_size, from_slice, to_slice, index_dimensions=0, index_dim_shape=1, dtype=np.float64):
diff --git a/pystencils/integer_functions.py b/pystencils/integer_functions.py
index 2fbc1ed673a230112ff7266922a7dc0f06a0eba2..4e583d9ab53469deef93c665c26876ae08364f4a 100644
--- a/pystencils/integer_functions.py
+++ b/pystencils/integer_functions.py
@@ -1,6 +1,6 @@
 import sympy as sp
 
-from pystencils.data_types import get_type_of_expression, collate_types
+from pystencils.data_types import collate_types, get_type_of_expression
 from pystencils.sympyextensions import is_integer_sequence
 
 bitwise_xor = sp.Function("bitwise_xor")
diff --git a/pystencils/integer_set_analysis.py b/pystencils/integer_set_analysis.py
index fc4a60b130f2671907e938020527580f0078e280..3560ba6ca1ad3f10ba456564aa74669273ef8dae 100644
--- a/pystencils/integer_set_analysis.py
+++ b/pystencils/integer_set_analysis.py
@@ -1,7 +1,7 @@
 """Transformations using integer sets based on ISL library"""
 
-import sympy as sp
 import islpy as isl
+import sympy as sp
 
 import pystencils.astnodes as ast
 from pystencils.transformations import parents_of_type
diff --git a/pystencils/jupyter.py b/pystencils/jupyter.py
index 08d71a4cdd56606b60a6333c5e1279053d57474b..f977e87c0b9c1b835eccf6670c4e4ec63eccd086 100644
--- a/pystencils/jupyter.py
+++ b/pystencils/jupyter.py
@@ -1,9 +1,11 @@
-import pystencils.plot as plt
-import matplotlib.animation as animation
-from IPython.display import HTML
-from tempfile import NamedTemporaryFile
 import base64
+from tempfile import NamedTemporaryFile
+
+import matplotlib.animation as animation
 import sympy as sp
+from IPython.display import HTML
+
+import pystencils.plot as plt
 
 __all__ = ['log_progress', 'make_imshow_animation', 'display_animation', 'set_display_mode']
 
diff --git a/pystencils/kerncraft_coupling/__init__.py b/pystencils/kerncraft_coupling/__init__.py
index 7822b3b540cef889035ca0654efcf374eab73469..8d2c3ad506692ad52c265ff61bb616fce6021f4e 100644
--- a/pystencils/kerncraft_coupling/__init__.py
+++ b/pystencils/kerncraft_coupling/__init__.py
@@ -1,4 +1,4 @@
-from .kerncraft_interface import PyStencilsKerncraftKernel, KerncraftParameters
 from .generate_benchmark import generate_benchmark, run_c_benchmark
+from .kerncraft_interface import KerncraftParameters, PyStencilsKerncraftKernel
 
 __all__ = ['PyStencilsKerncraftKernel', 'KerncraftParameters', 'generate_benchmark', 'run_c_benchmark']
diff --git a/pystencils/kerncraft_coupling/generate_benchmark.py b/pystencils/kerncraft_coupling/generate_benchmark.py
index f63be049a1fcfb2e6a5867bc8f7dc94123759165..c95c420d6c62d4428354f934a4e36fb7e7398b9d 100644
--- a/pystencils/kerncraft_coupling/generate_benchmark.py
+++ b/pystencils/kerncraft_coupling/generate_benchmark.py
@@ -1,12 +1,14 @@
-from jinja2 import Template
 import os
 import subprocess
-from pystencils.include import get_pystencils_include_path
-from pystencils.cpu.cpujit import get_compiler_config, run_compile_step
+
+from jinja2 import Template
+
+from pystencils.astnodes import PragmaBlock
 from pystencils.backends.cbackend import generate_c, get_headers
-from pystencils.sympyextensions import prod
+from pystencils.cpu.cpujit import get_compiler_config, run_compile_step
 from pystencils.data_types import get_base_type
-from pystencils.astnodes import PragmaBlock
+from pystencils.include import get_pystencils_include_path
+from pystencils.sympyextensions import prod
 
 benchmark_template = Template("""
 #include "kerncraft.h"
diff --git a/pystencils/kerncraft_coupling/kerncraft_interface.py b/pystencils/kerncraft_coupling/kerncraft_interface.py
index b58ccb96a28af75994837183b400807fbde9acb1..37a5109de80b0c975a5cb30043316e1c1e8e9e9e 100644
--- a/pystencils/kerncraft_coupling/kerncraft_interface.py
+++ b/pystencils/kerncraft_coupling/kerncraft_interface.py
@@ -1,19 +1,20 @@
+import warnings
+from collections import defaultdict
 from tempfile import TemporaryDirectory
+from typing import Optional
 
-import sympy as sp
-from collections import defaultdict
 import kerncraft
+import sympy as sp
 from kerncraft.kerncraft import KernelCode
-from typing import Optional
 from kerncraft.machinemodel import MachineModel
 
-from pystencils.kerncraft_coupling.generate_benchmark import generate_benchmark
-from pystencils.astnodes import LoopOverCoordinate, SympyAssignment, ResolvedFieldAccess, KernelFunction
+from pystencils.astnodes import (
+    KernelFunction, LoopOverCoordinate, ResolvedFieldAccess, SympyAssignment)
 from pystencils.field import get_layout_from_strides
+from pystencils.kerncraft_coupling.generate_benchmark import generate_benchmark
 from pystencils.sympyextensions import count_operations_in_ast
 from pystencils.transformations import filtered_tree_iteration
 from pystencils.utils import DotDict
-import warnings
 
 
 class PyStencilsKerncraftKernel(KernelCode):
diff --git a/pystencils/kernel_decorator.py b/pystencils/kernel_decorator.py
index 0063865b22b5a84839990637f3bdafad18e8d711..1ea8dcfbc4c671d8d0ba5634f2c55a93a39d9f23 100644
--- a/pystencils/kernel_decorator.py
+++ b/pystencils/kernel_decorator.py
@@ -1,9 +1,11 @@
 import ast
 import inspect
-import sympy as sp
 import textwrap
-from pystencils.sympyextensions import SymbolCreator
+
+import sympy as sp
+
 from pystencils.assignment import Assignment
+from pystencils.sympyextensions import SymbolCreator
 
 __all__ = ['kernel']
 
diff --git a/pystencils/kernelcreation.py b/pystencils/kernelcreation.py
index e8de7d2455ab159df5d9bb496c7abd410b60b6c0..ade980f55969a4005f2c5055ad27f861ab5524de 100644
--- a/pystencils/kernelcreation.py
+++ b/pystencils/kernelcreation.py
@@ -1,13 +1,15 @@
+import itertools
 from types import MappingProxyType
+
 import sympy as sp
-import itertools
+
 from pystencils.assignment import Assignment
-from pystencils.astnodes import LoopOverCoordinate, Conditional, Block, SympyAssignment
+from pystencils.astnodes import Block, Conditional, LoopOverCoordinate, SympyAssignment
 from pystencils.cpu.vectorization import vectorize
-from pystencils.simp.assignment_collection import AssignmentCollection
 from pystencils.gpucuda.indexing import indexing_creator_from_params
-from pystencils.transformations import remove_conditionals_in_staggered_kernel, loop_blocking, \
-    move_constants_before_loop
+from pystencils.simp.assignment_collection import AssignmentCollection
+from pystencils.transformations import (
+    loop_blocking, move_constants_before_loop, remove_conditionals_in_staggered_kernel)
 
 
 def create_kernel(assignments, target='cpu', data_type="double", iteration_slice=None, ghost_layers=None,
diff --git a/pystencils/kernelparameters.py b/pystencils/kernelparameters.py
index f6e19ef83def4331d0c3f4c3a45d08605263e984..11d30e09c8e351cb67ed3f7c3020c9243fba7557 100644
--- a/pystencils/kernelparameters.py
+++ b/pystencils/kernelparameters.py
@@ -14,7 +14,9 @@ e.g. `FieldShapeSymbol`, since a Field contains `FieldShapeSymbol`s in its shape
 would reference back to the field.
 """
 from sympy.core.cache import cacheit
-from pystencils.data_types import TypedSymbol, create_composite_type_from_string, PointerType, get_base_type
+
+from pystencils.data_types import (
+    PointerType, TypedSymbol, create_composite_type_from_string, get_base_type)
 
 SHAPE_DTYPE = create_composite_type_from_string("const int64")
 STRIDE_DTYPE = create_composite_type_from_string("const int64")
diff --git a/pystencils/llvm/kernelcreation.py b/pystencils/llvm/kernelcreation.py
index fcb403e783dfd4503ec2f8a6b93adea1a8be2a0d..38ac7fe6be818729eae3a935a4c14003f066e849 100644
--- a/pystencils/llvm/kernelcreation.py
+++ b/pystencils/llvm/kernelcreation.py
@@ -1,5 +1,5 @@
-from pystencils.transformations import insert_casts
 from pystencils.llvm.llvmjit import make_python_function
+from pystencils.transformations import insert_casts
 
 
 def create_kernel(assignments, function_name="kernel", type_info=None, split_groups=(),
diff --git a/pystencils/llvm/llvm.py b/pystencils/llvm/llvm.py
index c71fb5ab666fcb15b94bfe30af2611edbdfe3322..cf2207c0831f0d365033dc25ee4c3c701af9940e 100644
--- a/pystencils/llvm/llvm.py
+++ b/pystencils/llvm/llvm.py
@@ -1,12 +1,15 @@
-import sympy as sp
 import functools
-from sympy import S, Indexed
-from sympy.printing.printer import Printer
+
 import llvmlite.ir as ir
+import sympy as sp
+from sympy import Indexed, S
+from sympy.printing.printer import Printer
+
 from pystencils.assignment import Assignment
+from pystencils.data_types import (
+    collate_types, create_composite_type_from_string, create_type, get_type_of_expression,
+    to_llvm_type)
 from pystencils.llvm.control_flow import Loop
-from pystencils.data_types import create_type, to_llvm_type, get_type_of_expression, collate_types, \
-    create_composite_type_from_string
 
 
 def generate_llvm(ast_node, module=None, builder=None):
diff --git a/pystencils/llvm/llvmjit.py b/pystencils/llvm/llvmjit.py
index 545454cb9bb98bf29de3881260cd70962de62ed2..6dc40151e4495d5fa67f9c6081a442a558b1d09a 100644
--- a/pystencils/llvm/llvmjit.py
+++ b/pystencils/llvm/llvmjit.py
@@ -1,12 +1,15 @@
-import llvmlite.ir as ir
+import ctypes as ct
+
 import llvmlite.binding as llvm
+import llvmlite.ir as ir
 import numpy as np
-import ctypes as ct
+
 from pystencils.data_types import create_composite_type_from_string
-from ..data_types import to_ctypes, ctypes_from_llvm, StructType
-from .llvm import generate_llvm
 from pystencils.field import FieldType
 
+from ..data_types import StructType, ctypes_from_llvm, to_ctypes
+from .llvm import generate_llvm
+
 
 def build_ctypes_argument_list(parameter_specification, argument_dict):
     argument_dict = {k: v for k, v in argument_dict.items()}
diff --git a/pystencils/placeholder_function.py b/pystencils/placeholder_function.py
index aca93d16937d7efa37668b3c15d03f4aa7069166..18a0574b82292ecd9da0bff50f68d86811b472c7 100644
--- a/pystencils/placeholder_function.py
+++ b/pystencils/placeholder_function.py
@@ -1,5 +1,7 @@
-import sympy as sp
 from typing import List
+
+import sympy as sp
+
 from pystencils.assignment import Assignment
 from pystencils.astnodes import Node
 from pystencils.sympyextensions import is_constant
diff --git a/pystencils/plot.py b/pystencils/plot.py
index 24a8cdce7b9895b176985aef8d89a1fdff668a61..de1b1e32ebdf1ffd036ed1f95bb564485c91b7a0 100644
--- a/pystencils/plot.py
+++ b/pystencils/plot.py
@@ -3,9 +3,10 @@ This module extends the pyplot module with functions to show scalar and vector f
 simulation coordinate system (y-axis goes up), instead of the "image coordinate system" (y axis goes down) that
 matplotlib normally uses.
 """
-from matplotlib.pyplot import *
 from itertools import cycle
 
+from matplotlib.pyplot import *
+
 
 def vector_field(array, step=2, **kwargs):
     """Plots given vector field as quiver (arrow) plot.
diff --git a/pystencils/rng.py b/pystencils/rng.py
index 7e84e23f0ec0da3e0a5200df085d589ff9bbc7bd..eae916410eee6246b4cefcc11c31f9f0210e2ad9 100644
--- a/pystencils/rng.py
+++ b/pystencils/rng.py
@@ -1,5 +1,6 @@
-import sympy as sp
 import numpy as np
+import sympy as sp
+
 from pystencils import TypedSymbol
 from pystencils.astnodes import LoopOverCoordinate
 from pystencils.backends.cbackend import CustomCodeNode
diff --git a/pystencils/runhelper/db.py b/pystencils/runhelper/db.py
index e0655db3238b4ea9f4d70fb47695201bb0f00c38..acf5c6f7436fe43c76336deb709be635b5cec990 100644
--- a/pystencils/runhelper/db.py
+++ b/pystencils/runhelper/db.py
@@ -1,7 +1,9 @@
-import time
 import socket
-from typing import Dict, Sequence, Iterator
+import time
+from typing import Dict, Iterator, Sequence
+
 import blitzdb
+
 from pystencils.cpu.cpujit import get_compiler_config
 
 
diff --git a/pystencils/runhelper/parameterstudy.py b/pystencils/runhelper/parameterstudy.py
index 22d2bf2e3964e176a4e86895b2684ab508f170f5..0ad27fd5bdd426b74c515a37d500da29eb805864 100644
--- a/pystencils/runhelper/parameterstudy.py
+++ b/pystencils/runhelper/parameterstudy.py
@@ -1,16 +1,16 @@
-import json
 import datetime
+import itertools
+import json
 import os
 import socket
-import itertools
-from copy import deepcopy
 from collections import namedtuple
+from copy import deepcopy
 from time import sleep
-from typing import Dict, Callable, Sequence, Any, Tuple, Optional
+from typing import Any, Callable, Dict, Optional, Sequence, Tuple
+
 from pystencils.runhelper import Database
 from pystencils.utils import DotDict
 
-
 ParameterDict = Dict[str, Any]
 WeightFunction = Callable[[Dict], int]
 FilterFunction = Callable[[ParameterDict], Optional[ParameterDict]]
diff --git a/pystencils/session.py b/pystencils/session.py
index 53287ee9e444c31c355f5e90727615e6c198fa5a..51d2ef627282dba4caea1da53c2132c5ee97aca6 100644
--- a/pystencils/session.py
+++ b/pystencils/session.py
@@ -1,9 +1,9 @@
-import pystencils.sympy_gmpy_bug_workaround
-import pystencils.jupyter
-import sympy as sp
 import numpy as np
+import sympy as sp
+
 import pystencils as ps
+import pystencils.jupyter
 import pystencils.plot as plt
-
+import pystencils.sympy_gmpy_bug_workaround
 
 __all__ = ['sp', 'np', 'ps', 'plt']
diff --git a/pystencils/simp/__init__.py b/pystencils/simp/__init__.py
index 36efb062ded6ff27f2594193156762b3682e7932..ab0d608fb8efcd659d8811ef0e274f28e72c1cf0 100644
--- a/pystencils/simp/__init__.py
+++ b/pystencils/simp/__init__.py
@@ -1,8 +1,10 @@
 from .assignment_collection import AssignmentCollection
+from .simplifications import (
+    add_subexpressions_for_divisions, add_subexpressions_for_field_reads,
+    apply_on_all_subexpressions, apply_to_all_assignments,
+    subexpression_substitution_in_existing_subexpressions,
+    subexpression_substitution_in_main_assignments, sympy_cse, sympy_cse_on_assignment_list)
 from .simplificationstrategy import SimplificationStrategy
-from .simplifications import sympy_cse, sympy_cse_on_assignment_list, \
-    apply_to_all_assignments, apply_on_all_subexpressions, subexpression_substitution_in_existing_subexpressions, \
-    subexpression_substitution_in_main_assignments, add_subexpressions_for_divisions, add_subexpressions_for_field_reads
 
 __all__ = ['AssignmentCollection', 'SimplificationStrategy',
            'sympy_cse', 'sympy_cse_on_assignment_list', 'apply_to_all_assignments',
diff --git a/pystencils/simp/assignment_collection.py b/pystencils/simp/assignment_collection.py
index 8f0b481ce57aed9c1d64e62f062a6ed0f1c4168d..b15b87a4fc948c1fd86add59c64d5b16dce89afa 100644
--- a/pystencils/simp/assignment_collection.py
+++ b/pystencils/simp/assignment_collection.py
@@ -1,8 +1,10 @@
-import sympy as sp
 from copy import copy
-from typing import List, Optional, Dict, Any, Set, Sequence, Iterator, Iterable, Union
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Sequence, Set, Union
+
+import sympy as sp
+
 from pystencils.assignment import Assignment
-from pystencils.sympyextensions import fast_subs, count_operations, sort_assignments_topologically
+from pystencils.sympyextensions import count_operations, fast_subs, sort_assignments_topologically
 
 
 class AssignmentCollection:
diff --git a/pystencils/simp/simplifications.py b/pystencils/simp/simplifications.py
index d6077b8f6b494819289e7fbe1e4ce599b2cdac2d..22ff1bee22a25a66d00e51700dc07cf2b86856d7 100644
--- a/pystencils/simp/simplifications.py
+++ b/pystencils/simp/simplifications.py
@@ -1,9 +1,9 @@
-import sympy as sp
 from typing import Callable, List
 
-from pystencils import Field
+import sympy as sp
+
 from pystencils.assignment import Assignment
-from pystencils.field import AbstractField
+from pystencils.field import AbstractField, Field
 from pystencils.simp.assignment_collection import AssignmentCollection
 from pystencils.sympyextensions import subs_additive
 
diff --git a/pystencils/simp/simplificationstrategy.py b/pystencils/simp/simplificationstrategy.py
index f80734bab97f7f2e4c3db8baba6e8aa6af15002e..d9bcafa46262d4a9132e238666823556dfe20b23 100644
--- a/pystencils/simp/simplificationstrategy.py
+++ b/pystencils/simp/simplificationstrategy.py
@@ -1,6 +1,8 @@
-import sympy as sp
 from collections import namedtuple
-from typing import Callable, Any, Optional, Sequence
+from typing import Any, Callable, Optional, Sequence
+
+import sympy as sp
+
 from pystencils.simp.assignment_collection import AssignmentCollection
 
 
diff --git a/pystencils/slicing.py b/pystencils/slicing.py
index 0fab3678c7fbc6de5a61da2f47d07f46fb8e857a..2f44a00a91ba42d4fc6834a20fb21023080e4653 100644
--- a/pystencils/slicing.py
+++ b/pystencils/slicing.py
@@ -1,4 +1,5 @@
 import sympy as sp
+
 from pystencils.field import create_numpy_array_with_layout, get_layout_of_array
 
 
diff --git a/pystencils/stencil.py b/pystencils/stencil.py
index a6224e0792bdaa0e0eb4650173b2d43faa4816fd..f2201ccc1153e2a1fb65da38eec44d7bdbeeb275 100644
--- a/pystencils/stencil.py
+++ b/pystencils/stencil.py
@@ -1,8 +1,9 @@
 """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)
diff --git a/pystencils/sympyextensions.py b/pystencils/sympyextensions.py
index 6df8eedab803766895f4ffccd808caec22c29cce..2741f7ca51f1d3a7503c821e9ca183ac349ac859 100644
--- a/pystencils/sympyextensions.py
+++ b/pystencils/sympyextensions.py
@@ -1,13 +1,15 @@
 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')
 
diff --git a/pystencils/transformations.py b/pystencils/transformations.py
index 30cb69844e67333ba7f44e2cebcd444cb4437fd5..60a22d812578db85d7f375a74144352e431ffc62 100644
--- a/pystencils/transformations.py
+++ b/pystencils/transformations.py
@@ -1,19 +1,22 @@
+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:
diff --git a/pystencils/utils.py b/pystencils/utils.py
index 6e620b5f28ff6aee874d666e0881d889c1fdf033..5b97f7f24dbb33b14a324ca23ba9b676eab0057a 100644
--- a/pystencils/utils.py
+++ b/pystencils/utils.py
@@ -1,11 +1,11 @@
 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):
diff --git a/pystencils_tests/benchmark/benchmark.py b/pystencils_tests/benchmark/benchmark.py
index 6ecb6aaa828f9a2c42d53e09c4190ea11ee8cb84..29066127cea347299dfc3f52825a1ddf5d75e247 100644
--- a/pystencils_tests/benchmark/benchmark.py
+++ b/pystencils_tests/benchmark/benchmark.py
@@ -1,15 +1,17 @@
-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):
diff --git a/pystencils_tests/benchmark/generate.py b/pystencils_tests/benchmark/generate.py
index 09e2769e2289525089e92649e48713cc5e9e593d..fba398489ce1f19982ae1a3611bc5437f204af6b 100644
--- a/pystencils_tests/benchmark/generate.py
+++ b/pystencils_tests/benchmark/generate.py
@@ -1,6 +1,7 @@
-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()
-
-
diff --git a/pystencils_tests/test_address_of.py b/pystencils_tests/test_address_of.py
index 8de48e2bb0783dc66452a0bf31a7a7529d8d8292..6e23d5ffd6513cba16acb2d711a9de0cf16c222e 100644
--- a/pystencils_tests/test_address_of.py
+++ b/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():
diff --git a/pystencils_tests/test_assignment_collection.py b/pystencils_tests/test_assignment_collection.py
index 4bf27b22e9a2a6ff7dc6f7944841bf61e8679542..1a8f6f9dc5b4f7091e302741ff73b9994f4ed3a2 100644
--- a/pystencils_tests/test_assignment_collection.py
+++ b/pystencils_tests/test_assignment_collection.py
@@ -1,4 +1,5 @@
 import sympy as sp
+
 from pystencils import Assignment, AssignmentCollection
 from pystencils.simp.assignment_collection import SymbolGen
 
diff --git a/pystencils_tests/test_assignment_from_stencil.py b/pystencils_tests/test_assignment_from_stencil.py
index b3b193f8e1966e963dbf8d3815e98cfebb641e2d..a4bb705d693403af3ea8cc3d44142f52d92b8668 100644
--- a/pystencils_tests/test_assignment_from_stencil.py
+++ b/pystencils_tests/test_assignment_from_stencil.py
@@ -1,6 +1,7 @@
-import pystencils
 import numpy as np
 
+import pystencils
+
 
 def test_assignment_from_stencil():
 
diff --git a/pystencils_tests/test_blocking.py b/pystencils_tests/test_blocking.py
index c554da74daefc618850028595c30a9eb1cf2754a..579ba41997cec4990ad4da00ae811cdb0b564bd2 100644
--- a/pystencils_tests/test_blocking.py
+++ b/pystencils_tests/test_blocking.py
@@ -1,5 +1,6 @@
-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)
-
diff --git a/pystencils_tests/test_blocking_staggered.py b/pystencils_tests/test_blocking_staggered.py
index d32e601736721f4a4be4cb69da582672fa3e22c1..207d05a280f790c5c0b74a50e7ecfb252bd04276 100644
--- a/pystencils_tests/test_blocking_staggered.py
+++ b/pystencils_tests/test_blocking_staggered.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 import pystencils as ps
 
 
diff --git a/pystencils_tests/test_boundary.py b/pystencils_tests/test_boundary.py
index 6aaf4e696bd27766ae0fc06186fa6521e6d9a8e7..096b1348fc59181e14eb15042d8db0098e71c521 100644
--- a/pystencils_tests/test_boundary.py
+++ b/pystencils_tests/test_boundary.py
@@ -1,9 +1,10 @@
-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
 
diff --git a/pystencils_tests/test_buffer.py b/pystencils_tests/test_buffer.py
index 3f513a1f5a8dc298b7ed085aaa0289e6de096405..7ea7fd2a19759201f9a6ebd6a63877a29675710e 100644
--- a/pystencils_tests/test_buffer.py
+++ b/pystencils_tests/test_buffer.py
@@ -1,11 +1,12 @@
 """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)]
 
diff --git a/pystencils_tests/test_buffer_gpu.py b/pystencils_tests/test_buffer_gpu.py
index 1af0e6cf5b9add003c33e84d847457064898d4c3..fc27a2331be1690b8bb1d0da043b47b3ba6fcfc9 100644
--- a/pystencils_tests/test_buffer_gpu.py
+++ b/pystencils_tests/test_buffer_gpu.py
@@ -1,12 +1,15 @@
 """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
diff --git a/pystencils_tests/test_conditional_vec.py b/pystencils_tests/test_conditional_vec.py
index b66cffcb862ca1332aa735373e44c8249f9d64c4..d3fc3dc66b4254e4b78a7699ce23316afb830132 100644
--- a/pystencils_tests/test_conditional_vec.py
+++ b/pystencils_tests/test_conditional_vec.py
@@ -1,7 +1,8 @@
-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
 
 
diff --git a/pystencils_tests/test_cudagpu.py b/pystencils_tests/test_cudagpu.py
index ad13ac96f3d36c6c5480bfdd33c957b7722063e9..77790229f48b736258d343a4670c06e66a417838 100644
--- a/pystencils_tests/test_cudagpu.py
+++ b/pystencils_tests/test_cudagpu.py
@@ -1,13 +1,14 @@
 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)
diff --git a/pystencils_tests/test_datahandling.py b/pystencils_tests/test_datahandling.py
index 887c855dbb1c0be11847f0d3a34f849edea08ce9..cdee059c218a67ad9adc824f41fa09ae3df2f19b 100644
--- a/pystencils_tests/test_datahandling.py
+++ b/pystencils_tests/test_datahandling.py
@@ -1,8 +1,10 @@
-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):
diff --git a/pystencils_tests/test_datahandling_parallel.py b/pystencils_tests/test_datahandling_parallel.py
index 5111bd247eda4be951686095ecdfa94e8df54bfa..52ccb6bce34b2ca115b19a8d00fa31da622b8ff4 100644
--- a/pystencils_tests/test_datahandling_parallel.py
+++ b/pystencils_tests/test_datahandling_parallel.py
@@ -1,9 +1,10 @@
 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)
diff --git a/pystencils_tests/test_derivative.py b/pystencils_tests/test_derivative.py
index 74ad02e38c8cee23fa7e1d99a0abbe4a748c7cf1..82738429c4c99789d1c719ebd03d8f6cf8c46641 100644
--- a/pystencils_tests/test_derivative.py
+++ b/pystencils_tests/test_derivative.py
@@ -1,8 +1,9 @@
 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():
diff --git a/pystencils_tests/test_dtype_check.py b/pystencils_tests/test_dtype_check.py
index fdbcb9b224b982fa974589f777e1259008204b73..842e89c247d16b0abea7be81ec1ae7dd8db7f6bd 100644
--- a/pystencils_tests/test_dtype_check.py
+++ b/pystencils_tests/test_dtype_check.py
@@ -1,7 +1,8 @@
-import pystencils
 import numpy as np
 import pytest
 
+import pystencils
+
 
 def test_dtype_check_wrong_type():
     array = np.ones((10, 20)).astype(np.float32)
diff --git a/pystencils_tests/test_fast_approximation.py b/pystencils_tests/test_fast_approximation.py
index bc07ae9b8c133fb136fcca25aeea00c256e181d1..76bef174eb7451234dcf347818fdb2d456ce7005 100644
--- a/pystencils_tests/test_fast_approximation.py
+++ b/pystencils_tests/test_fast_approximation.py
@@ -1,7 +1,8 @@
 import sympy as sp
+
 import pystencils as ps
-from pystencils.fast_approximation import insert_fast_divisions, insert_fast_sqrts, fast_sqrt, fast_inv_sqrt, \
-    fast_division
+from pystencils.fast_approximation import (
+    fast_division, fast_inv_sqrt, fast_sqrt, insert_fast_divisions, insert_fast_sqrts)
 
 
 def test_fast_sqrt():
diff --git a/pystencils_tests/test_fd_derivation.py b/pystencils_tests/test_fd_derivation.py
index 6de6e6a2834e2be08dbe4d7cc08fcb07fd7666cc..73d38dc10031ea3bb287d313c174bbbb96f8ff13 100644
--- a/pystencils_tests/test_fd_derivation.py
+++ b/pystencils_tests/test_fd_derivation.py
@@ -1,5 +1,6 @@
 import pytest
 import sympy as sp
+
 from pystencils.utils import LinearEquationSystem
 
 
diff --git a/pystencils_tests/test_field.py b/pystencils_tests/test_field.py
index 67b34e7980d2d2b4538b768b7f956487ce54a26f..4742282630dbf7046d73df791da8cbd02524e6b5 100644
--- a/pystencils_tests/test_field.py
+++ b/pystencils_tests/test_field.py
@@ -1,8 +1,9 @@
-import pytest
 import numpy as np
+import pytest
 import sympy as sp
+
 import pystencils as ps
-from pystencils import Field, FieldType
+from pystencils.field import Field, FieldType
 from pystencils.field import layout_string_to_tuple
 
 
diff --git a/pystencils_tests/test_finite_differences.py b/pystencils_tests/test_finite_differences.py
index be2dacd3a5f313efa5dc8a036c34b9b29b260dc0..2491247c2aa49d2775be39a929a3e66b1b3439f2 100644
--- a/pystencils_tests/test_finite_differences.py
+++ b/pystencils_tests/test_finite_differences.py
@@ -1,8 +1,9 @@
 import sympy as sp
+
 import pystencils as ps
 from pystencils.astnodes import LoopOverCoordinate
-from pystencils.fd.spatial import fd_stencils_standard, fd_stencils_isotropic, discretize_spatial
 from pystencils.fd import diff
+from pystencils.fd.spatial import discretize_spatial, fd_stencils_isotropic, fd_stencils_standard
 
 
 def test_spatial_2d_unit_sum():
diff --git a/pystencils_tests/test_indexed_kernels.py b/pystencils_tests/test_indexed_kernels.py
index 13dbbd4982555adb6237f3eb796302da1b979cad..fd994c7f9326d0b175a1adf7042e43938e621ad3 100644
--- a/pystencils_tests/test_indexed_kernels.py
+++ b/pystencils_tests/test_indexed_kernels.py
@@ -1,5 +1,6 @@
 import numpy as np
-from pystencils import Field, Assignment
+
+from pystencils import Assignment, Field
 from pystencils.cpu import create_indexed_kernel, make_python_function
 
 
diff --git a/pystencils_tests/test_jacobi_cbackend.py b/pystencils_tests/test_jacobi_cbackend.py
index ad4f82e89dcb04b25a3f5e604e28d33d4d86360e..9206aeedaf4bb035444f9280cf58968c9ca385c9 100644
--- a/pystencils_tests/test_jacobi_cbackend.py
+++ b/pystencils_tests/test_jacobi_cbackend.py
@@ -1,9 +1,11 @@
 import numpy as np
+
 from pystencils import show_code
-from pystencils.transformations import move_constants_before_loop, make_loop_over_domain, resolve_field_accesses
-from pystencils.field import Field
-from pystencils.astnodes import SympyAssignment, Block, KernelFunction
+from pystencils.astnodes import Block, KernelFunction, SympyAssignment
 from pystencils.cpu import make_python_function
+from pystencils.field import Field
+from pystencils.transformations import (
+    make_loop_over_domain, move_constants_before_loop, resolve_field_accesses)
 
 
 def test_jacobi_fixed_field_size():
diff --git a/pystencils_tests/test_jacobi_llvm.py b/pystencils_tests/test_jacobi_llvm.py
index f6e4825735cc4eedba5eabde720e601d6b20b398..2965cf245c6bf34e001d1ac67ad5b350c1219247 100644
--- a/pystencils_tests/test_jacobi_llvm.py
+++ b/pystencils_tests/test_jacobi_llvm.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from pystencils import Assignment, Field
 from pystencils.llvm import create_kernel, make_python_function
 from pystencils.llvm.llvmjit import generate_and_jit
diff --git a/pystencils_tests/test_kerncraft_coupling.py b/pystencils_tests/test_kerncraft_coupling.py
index 5d3485e4ab3f26e5d8d728d30ec06dcbaa5a4d2a..058c35c2a284da6d84928505587e6fbf12477843 100644
--- a/pystencils_tests/test_kerncraft_coupling.py
+++ b/pystencils_tests/test_kerncraft_coupling.py
@@ -1,16 +1,14 @@
 import os
+
 import numpy as np
-import sympy as sp
-from pystencils import Field, Assignment
-from pystencils.kerncraft_coupling import PyStencilsKerncraftKernel, KerncraftParameters
-from pystencils.kerncraft_coupling.generate_benchmark import generate_benchmark
-from pystencils.cpu import create_kernel
 import pytest
+import sympy as sp
+import kerncraft
 
-from kerncraft.models import ECMData, ECM, Benchmark
-from kerncraft.machinemodel import MachineModel
-from kerncraft.kernel import KernelCode
-
+from pystencils import Assignment, Field
+from pystencils.cpu import create_kernel
+from pystencils.kerncraft_coupling import KerncraftParameters, PyStencilsKerncraftKernel
+from pystencils.kerncraft_coupling.generate_benchmark import generate_benchmark
 
 SCRIPT_FOLDER = os.path.dirname(os.path.realpath(__file__))
 INPUT_FOLDER = os.path.join(SCRIPT_FOLDER, "kerncraft_inputs")
@@ -19,11 +17,11 @@ INPUT_FOLDER = os.path.join(SCRIPT_FOLDER, "kerncraft_inputs")
 @pytest.mark.kernkraft
 def test_compilation():
     machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = MachineModel(path_to_yaml=machine_file_path)
+    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
 
     kernel_file_path = os.path.join(INPUT_FOLDER, "2d-5pt.c")
     with open(kernel_file_path) as kernel_file:
-        reference_kernel = KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
+        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
         reference_kernel.as_code('likwid')
 
     size = [30, 50, 3]
@@ -41,17 +39,17 @@ def test_compilation():
 @pytest.mark.kernkraft
 def analysis(kernel, model='ecmdata'):
     machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = MachineModel(path_to_yaml=machine_file_path)
+    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
     if model == 'ecmdata':
-        model = ECMData(kernel, machine, KerncraftParameters())
+        model = kerncraft.models.ECMData(kernel, machine, KerncraftParameters())
     elif model == 'ecm':
-        model = ECM(kernel, machine, KerncraftParameters())
+        model = kerncraft.models.ECM(kernel, machine, KerncraftParameters())
         # model.analyze()
         # model.plot()
     elif model == 'benchmark':
-        model = Benchmark(kernel, machine, KerncraftParameters())
+        model = kerncraft.models.Benchmark(kernel, machine, KerncraftParameters())
     else:
-        model = ECM(kernel, machine, KerncraftParameters())
+        model = kerncraft.models.ECM(kernel, machine, KerncraftParameters())
     model.analyze()
     return model
 
@@ -62,9 +60,9 @@ def test_3d_7pt_iaca():
     size = [20, 200, 200]
     kernel_file_path = os.path.join(INPUT_FOLDER, "3d-7pt.c")
     machine_file_path = os.path.join(INPUT_FOLDER, "default_machine_file.yaml")
-    machine = MachineModel(path_to_yaml=machine_file_path)
+    machine = kerncraft.machinemodel.MachineModel(path_to_yaml=machine_file_path)
     with open(kernel_file_path) as kernel_file:
-        reference_kernel = KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
+        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=machine, filename=kernel_file_path)
     reference_kernel.set_constant('M', size[0])
     reference_kernel.set_constant('N', size[1])
     assert size[1] == size[2]
@@ -89,7 +87,7 @@ def test_2d_5pt():
     size = [30, 50, 3]
     kernel_file_path = os.path.join(INPUT_FOLDER, "2d-5pt.c")
     with open(kernel_file_path) as kernel_file:
-        reference_kernel = KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
+        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
     reference = analysis(reference_kernel)
 
     arr = np.zeros(size)
@@ -111,7 +109,7 @@ def test_3d_7pt():
     size = [30, 50, 50]
     kernel_file_path = os.path.join(INPUT_FOLDER, "3d-7pt.c")
     with open(kernel_file_path) as kernel_file:
-        reference_kernel = KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
+        reference_kernel = kerncraft.kernel.KernelCode(kernel_file.read(), machine=None, filename=kernel_file_path)
     reference_kernel.set_constant('M', size[0])
     reference_kernel.set_constant('N', size[1])
     assert size[1] == size[2]
diff --git a/pystencils_tests/test_loop_cutting.py b/pystencils_tests/test_loop_cutting.py
index 163b6cebb29ec98320b50ff274380bf25fc4e9f3..58126928daea4e7e6df5e0e71b3e57ac1491cff2 100644
--- a/pystencils_tests/test_loop_cutting.py
+++ b/pystencils_tests/test_loop_cutting.py
@@ -1,13 +1,14 @@
-import sympy as sp
 import numpy as np
+import sympy as sp
+
 import pystencils as ps
-from pystencils import Field
-from pystencils.cpu import create_kernel, make_python_function
+import pystencils.astnodes as ast
+from pystencils.field import Field
 from pystencils.astnodes import Conditional, LoopOverCoordinate, SympyAssignment
+from pystencils.cpu import create_kernel, make_python_function
 from pystencils.kernelcreation import create_staggered_kernel
-from pystencils.transformations import move_constants_before_loop
-import pystencils.astnodes as ast
-from pystencils.transformations import simplify_conditionals, cleanup_blocks, cut_loop
+from pystencils.transformations import (
+    cleanup_blocks, cut_loop, move_constants_before_loop, simplify_conditionals)
 
 
 def offsets_in_plane(normal_plane, offset_int, dimension):
diff --git a/pystencils_tests/test_move_constant_before_loop.py b/pystencils_tests/test_move_constant_before_loop.py
index a76ab82c2ee914451a005378283598c1bb1991d7..bec180deea5a82c3123f9bf14cd6045dbccfe91b 100644
--- a/pystencils_tests/test_move_constant_before_loop.py
+++ b/pystencils_tests/test_move_constant_before_loop.py
@@ -1,6 +1,7 @@
-import pystencils as ps
 import numpy as np
-from pystencils.astnodes import LoopOverCoordinate, Block, SympyAssignment, TypedSymbol
+
+import pystencils as ps
+from pystencils.astnodes import Block, LoopOverCoordinate, SympyAssignment, TypedSymbol
 from pystencils.transformations import move_constants_before_loop
 
 
diff --git a/pystencils_tests/test_parameterstudy.py b/pystencils_tests/test_parameterstudy.py
index 2b58e756671ef91814204fc2e3f76942990733fb..be5058d6cd32afc75a9340282e8db307f28c803a 100644
--- a/pystencils_tests/test_parameterstudy.py
+++ b/pystencils_tests/test_parameterstudy.py
@@ -1,7 +1,8 @@
 import io
 import json
-from http.server import HTTPServer, BaseHTTPRequestHandler
+from http.server import BaseHTTPRequestHandler, HTTPServer
 from tempfile import TemporaryDirectory
+
 from pystencils.runhelper import ParameterStudy
 
 
diff --git a/pystencils_tests/test_pickle_support.py b/pystencils_tests/test_pickle_support.py
index 82d8e1f3607e21b9ab61a7ceafe0efffa7be0dee..462645198881a54ec5a33ba10c2ccea69e44d702 100644
--- a/pystencils_tests/test_pickle_support.py
+++ b/pystencils_tests/test_pickle_support.py
@@ -1,6 +1,8 @@
-from pystencils import Field, TypedSymbol
 from copy import copy, deepcopy
 
+from pystencils.field import Field
+from pystencils.data_types import TypedSymbol
+
 
 def test_field_access():
     field = Field.create_generic('some_field', spatial_dimensions=2, index_dimensions=0)
diff --git a/pystencils_tests/test_plot.py b/pystencils_tests/test_plot.py
index 2e51343ec46779f934191933c86815d2dd30736c..6234334bb91352c80c643c474c76c15b968ce1c7 100644
--- a/pystencils_tests/test_plot.py
+++ b/pystencils_tests/test_plot.py
@@ -1,6 +1,8 @@
 import os
 from tempfile import TemporaryDirectory
+
 import numpy as np
+
 import pystencils.plot as plt
 
 
diff --git a/pystencils_tests/test_random.py b/pystencils_tests/test_random.py
index 2995cbdd6a81d289d020daf27d1903d0fd46b763..f86644875acce6679473336705b929f5f3083e6e 100644
--- a/pystencils_tests/test_random.py
+++ b/pystencils_tests/test_random.py
@@ -1,6 +1,7 @@
 import numpy as np
+
 import pystencils as ps
-from pystencils.rng import PhiloxTwoDoubles, PhiloxFourFloats
+from pystencils.rng import PhiloxFourFloats, PhiloxTwoDoubles
 
 
 def test_philox_double():
diff --git a/pystencils_tests/test_simplification_strategy.py b/pystencils_tests/test_simplification_strategy.py
index 957bee2ba7bd0ca79037b3fb8cfe8a95da702a15..189482c006197160e1f49771dc534206f8d0ef9e 100644
--- a/pystencils_tests/test_simplification_strategy.py
+++ b/pystencils_tests/test_simplification_strategy.py
@@ -1,7 +1,9 @@
 import sympy as sp
+
 from pystencils import Assignment, AssignmentCollection
-from pystencils.simp import SimplificationStrategy, apply_on_all_subexpressions, \
-    subexpression_substitution_in_existing_subexpressions
+from pystencils.simp import (
+    SimplificationStrategy, apply_on_all_subexpressions,
+    subexpression_substitution_in_existing_subexpressions)
 
 
 def test_simplification_strategy():
diff --git a/pystencils_tests/test_size_and_layout_checks.py b/pystencils_tests/test_size_and_layout_checks.py
index ecc454638e401004686bf41b5926ed16b3c2f8b9..597bf2c4d1ca32074e964141054e14313a288bea 100644
--- a/pystencils_tests/test_size_and_layout_checks.py
+++ b/pystencils_tests/test_size_and_layout_checks.py
@@ -1,8 +1,9 @@
 import numpy as np
 import pytest
-from pystencils import Field, Assignment, fields, create_kernel
 import sympy as sp
 
+from pystencils import Assignment, Field, create_kernel, fields
+
 
 def test_size_check():
     """Kernel with two fixed-sized fields creating with same size but calling with wrong size"""
diff --git a/pystencils_tests/test_size_and_layout_checks_llvm.py b/pystencils_tests/test_size_and_layout_checks_llvm.py
index 96b9bc05427aea1b34fcbf71292aa0d3a03cd809..8de8018f99f5be73dc899b6a649fc4d3a5e1923a 100644
--- a/pystencils_tests/test_size_and_layout_checks_llvm.py
+++ b/pystencils_tests/test_size_and_layout_checks_llvm.py
@@ -1,5 +1,6 @@
 import numpy as np
-from pystencils import Field, Assignment
+
+from pystencils import Assignment, Field
 from pystencils.llvm import create_kernel, make_python_function
 
 
diff --git a/pystencils_tests/test_sliced_iteration.py b/pystencils_tests/test_sliced_iteration.py
index 756937998171a56a31cb534d7f06508d1b31febc..1749745684872e75c199602b281e9622c02a257b 100644
--- a/pystencils_tests/test_sliced_iteration.py
+++ b/pystencils_tests/test_sliced_iteration.py
@@ -1,6 +1,7 @@
 import numpy as np
 import sympy as sp
-from pystencils import TypedSymbol, make_slice, Assignment, create_kernel, Field
+
+from pystencils import Assignment, Field, TypedSymbol, create_kernel, make_slice
 from pystencils.simp import sympy_cse_on_assignment_list
 
 
diff --git a/pystencils_tests/test_stencils.py b/pystencils_tests/test_stencils.py
index ea040a371a5ca20ec60c9d2fae6243260c14c5fa..bf1418e053d41ebeb80b6ae623f1834b24a8a713 100644
--- a/pystencils_tests/test_stencils.py
+++ b/pystencils_tests/test_stencils.py
@@ -1,3 +1 @@
 import pystencils as ps
-
-
diff --git a/pystencils_tests/test_struct_types.py b/pystencils_tests/test_struct_types.py
index 0a20ca28a6a98b1f0d604ca680c4d9035cdc7877..5d8de3da654dbedbef1df30cb011e26bb18716a7 100644
--- a/pystencils_tests/test_struct_types.py
+++ b/pystencils_tests/test_struct_types.py
@@ -1,5 +1,6 @@
 import numpy as np
-from pystencils import Field, create_kernel, Assignment
+
+from pystencils import Assignment, Field, create_kernel
 
 
 def test_fixed_sized_field():
diff --git a/pystencils_tests/test_vectorization.py b/pystencils_tests/test_vectorization.py
index 2f7d0f91956278f8769852ad10d6395ba5663415..1505c7543ee632d1a80a0405fef8e7080fc9bd22 100644
--- a/pystencils_tests/test_vectorization.py
+++ b/pystencils_tests/test_vectorization.py
@@ -1,5 +1,6 @@
 import numpy as np
 import sympy as sp
+
 import pystencils as ps
 from pystencils.backends.simd_instruction_sets import get_supported_instruction_sets
 from pystencils.cpu.vectorization import vectorize