Import sorting using isort

pystencils/kerncraft_coupling/__init__.py

-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']

pystencils/kerncraft_coupling/generate_benchmark.py

-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"

pystencils/kerncraft_coupling/kerncraft_interface.py

+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):

pystencils/kernel_decorator.py

 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']
 

pystencils/kernelcreation.py

+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,

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")

pystencils/llvm/kernelcreation.py

-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=(),

pystencils/llvm/llvm.py

-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):

pystencils/llvm/llvmjit.py

-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()}

pystencils/placeholder_function.py

-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

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.

pystencils/rng.py

-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

pystencils/runhelper/db.py

-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
 
 

pystencils/runhelper/parameterstudy.py

-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]]

pystencils/session.py

-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']

pystencils/simp/__init__.py

 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',

pystencils/simp/assignment_collection.py

-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:

pystencils/simp/simplifications.py

-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
 

pystencils/simp/simplificationstrategy.py

-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
 
 

pystencils/slicing.py

 import sympy as sp
+
 from pystencils.field import create_numpy_array_with_layout, get_layout_of_array