tomwer 1.1.0rc7__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/core/process/reconstruction/saaxis/saaxis.py

@@ -32,48 +32,52 @@ __license__ = "MIT"
 __date__ = "10/02/2021"
 
 
-import os
 import copy
-import h5py
-import numpy
 import logging
+import os
 from typing import Iterable, Optional
-from silx.io.url import DataUrl
-from tomoscan.io import HDF5File
-from processview.core.manager import ProcessManager, DatasetState
-from processview.core.superviseprocess import SuperviseProcess
+
+import h5py
+import numpy
 from nabu.pipeline.config import get_default_nabu_config
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
-from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.scanfactory import ScanFactory
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.io.url import DataUrl
+from tomoscan.io import HDF5File
+
+import tomwer.version
+from tomwer.core.process.reconstruction.axis import AxisRP
+from tomwer.core.process.reconstruction.nabu.nabuscores import (
+    run_nabu_one_slice_several_config,
+)
 from tomwer.core.process.reconstruction.nabu.nabuslices import (
     SingleSliceRunner,
     interpret_tomwer_configuration,
 )
-from tomwer.core.utils.slurm import is_slurm_available
-from tomwer.core.volume.volumefactory import VolumeFactory
-from tomwer.io.utils.utils import get_slice_data
-from ..nabu import utils
+from tomwer.core.process.reconstruction.scores import (
+    ComputedScore,
+    apply_roi,
+    compute_score,
+    get_disk_mask_radius,
+)
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from .params import ReconstructionMode
-from .params import SAAxisParams
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils import logconfig
 from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-import tomwer.version
 from tomwer.core.progress import Progress
-from tomwer.core.process.reconstruction.axis import AxisRP
-from tomwer.core.process.reconstruction.scores import compute_score
-from tomwer.core.process.reconstruction.scores import ComputedScore
-from tomwer.core.process.reconstruction.scores import get_disk_mask_radius, apply_roi
-from tomwer.core.process.reconstruction.nabu.nabuscores import (
-    run_nabu_one_slice_several_config,
-)
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils import logconfig
 from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.utils.slurm import is_slurm_available
+from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.io.utils.utils import get_slice_data
 
+from ..nabu import utils
+from .params import ReconstructionMode, SAAxisParams
 
 _logger = logging.getLogger(__name__)
 
@@ -116,18 +120,16 @@ def one_slice_several_cor(
     nabu_output_config = nabu_config.get("output", {})
     file_format = nabu_output_config.get("file_format", "hdf5")
     cluster_config = configuration.cluster_config
-    _logger.info(
-        "launch reconstruction of slice {} and cors {}".format(slice_index, cors)
-    )
+    _logger.info(f"launch reconstruction of slice {slice_index} and cors {cors}")
     if mode is ReconstructionMode.VERTICAL:
         if isinstance(slice_index, str):
             if not slice_index == "middle":
-                raise ValueError("slice index {} not recognized".format(slice_index))
+                raise ValueError(f"slice index {slice_index} not recognized")
         elif not len(slice_index) == 1:
-            raise ValueError("{} mode only manage one slice".format(mode.value))
+            raise ValueError(f"{mode.value} mode only manage one slice")
         else:
             slice_index = list(slice_index.values())[0]
-        advancement = Progress("saaxis - slice {} of {}".format(slice_index, scan))
+        advancement = Progress(f"saaxis - slice {slice_index} of {scan}")
 
         _, cor_reconstructions, outs, errs, future_tomo_objs = run_slice_reconstruction(
             scan=scan,
@@ -142,7 +144,7 @@ def one_slice_several_cor(
             process_id=process_id,
         )
     else:
-        raise ValueError("{} is not handled for now".format(mode))
+        raise ValueError(f"{mode} is not handled for now")
 
     # treat future
     if output_dir is None:
@@ -173,7 +175,7 @@ def one_slice_several_cor(
                 db=db,
                 ctf=ctf,
             )
-            file_prefix = "cor_{}_{}".format(_file_name, cor)
+            file_prefix = f"cor_{_file_name}_{cor}"
 
             recons_vol_id = utils.get_recons_volume_identifier(
                 scan=scan,
@@ -280,8 +282,7 @@ def one_slice_several_cor(
                     data = get_slice_data(url=url)
                 except Exception as e:
                     _logger.error(
-                        "Fail to compute a score for {}. Reason is {}"
-                        "".format(url.path(), str(e))
+                        f"Fail to compute a score for {url.path()}. Reason is {e}"
                     )
                     datasets_[cor] = (url, None)
                 else:
@@ -292,14 +293,12 @@ def one_slice_several_cor(
                             data = data.reshape(data.shape[0], data.shape[1])
                         else:
                             raise ValueError(
-                                "Data is expected to be 2D. Not {}".format(data.ndim)
+                                f"Data is expected to be 2D. Not {data.ndim}D"
                             )
                     elif data.ndim == 2:
                         pass
                     else:
-                        raise ValueError(
-                            "Data is expected to be 2D. Not {}".format(data.ndim)
-                        )
+                        raise ValueError("Data is expected to be 2D. Not {data.ndim}D")
 
                     datasets_[cor] = (url, data)
             return datasets_
@@ -506,9 +505,7 @@ class SAAxisProcess(
         elif isinstance(scan, dict):
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
         # TODO: look and update if there is some nabu reconstruction
         # or axis information to be used back
         configuration = self.get_configuration()
@@ -527,17 +524,13 @@ class SAAxisProcess(
             ):
                 params.estimated_cor = relative_cor
                 _logger.info(
-                    "{}: set estimated cor from previously computed cor ({})".format(
-                        str(scan), params.estimated_cor
-                    )
+                    f"{scan}: set estimated cor from previously computed cor ({params.estimated_cor})"
                 )
         #  from scan.estimated_cor_position
         if params.estimated_cor is None and scan.estimated_cor_frm_motor is not None:
             params.estimated_cor = scan.estimated_cor_frm_motor
             _logger.info(
-                "{}: set estimated cor from motor position ({})".format(
-                    str(scan), params.estimated_cor
-                )
+                f"{scan}: set estimated cor from motor position ({params.estimated_cor})"
             )
         if scan.dim_1 is not None:
             params.image_width = scan.dim_1
@@ -575,17 +568,13 @@ class SAAxisProcess(
             slice_index = self.get_configuration().get("slice_index", None)
 
             if cors_res is None:
-                info = "fail to compute cor scores of slice {} for scan {}." "".format(
-                    slice_index, scan
-                )
+                info = f"fail to compute cor scores of slice {slice_index} for scan {scan}."
                 _logger.processFailed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan, process=self, state=DatasetState.FAILED, details=info
                 )
             else:
-                info = "cor scores of slice {} for scan {} computed." "".format(
-                    slice_index, scan
-                )
+                info = f"cor scores of slice {slice_index} for scan {scan} computed."
                 _logger.processSucceed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan,

tomwer/core/process/reconstruction/sadeltabeta/__init__.py

@@ -1,2 +1,2 @@
-from .sadeltabeta import SADeltaBetaProcess  # noqa F401
 from .params import SADeltaBetaParams  # noqa F401
+from .sadeltabeta import SADeltaBetaProcess  # noqa F401

tomwer/core/process/reconstruction/sadeltabeta/params.py

@@ -28,10 +28,11 @@ __license__ = "MIT"
 __date__ = "04/05/2021"
 
 
-from tomwer.core.process.reconstruction.scores.params import SABaseParams
-from tomwer.core.process.reconstruction.nabu.utils import retrieve_lst_of_value_from_str
 import typing
 
+from tomwer.core.process.reconstruction.nabu.utils import retrieve_lst_of_value_from_str
+from tomwer.core.process.reconstruction.scores.params import SABaseParams
+
 
 class SADeltaBetaParams(SABaseParams):
     """Parameters for the semi-automatic axis calculation"""
@@ -62,20 +63,18 @@ class SADeltaBetaParams(SABaseParams):
         return self._selected_db
 
     def to_dict(self) -> dict:
-        dict = super().to_dict()
-        dict.update(
+        my_dict = super().to_dict()
+        my_dict.update(
             {
                 "delta_beta_values": self.delta_beta_values,
                 "selected_db_value": self.selected_delta_beta_value,
             }
         )
-        return dict
+        return my_dict
 
     def load_from_dict(self, dict_: dict):
         if not isinstance(dict_, dict):
-            raise TypeError(
-                "dict_ should be an instance of dict not {}".format(type(dict_))
-            )
+            raise TypeError(f"dict_ should be an instance of dict not {type(dict_)}")
         super().load_from_dict(dict_)
         if "delta_beta_values" in dict_:
             self.delta_beta_values = dict_["delta_beta_values"]
@@ -99,12 +98,9 @@ class SADeltaBetaParams(SABaseParams):
         if self.slice_indexes is None:
             missing_information.append("slice index not provided")
         if len(missing_information) > 0:
+            missing_information_str = " ; ".join(missing_information)
             raise ValueError(
-                str(
-                    "Some informations are missing: {}".format(
-                        " ; ".join(missing_information)
-                    )
-                )
+                f"Some informations are missing: {missing_information_str}"
             )
 
     def __str__(self):

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -32,45 +32,51 @@ __license__ = "MIT"
 __date__ = "28/10/2021"
 
 
-import os
 import logging
-import h5py
-import numpy
+import os
 from copy import copy
 from typing import Optional, Union
+
+import h5py
+import numpy
 from nabu.pipeline.config import get_default_nabu_config
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
-from processview.core.manager import ProcessManager, DatasetState
+from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
+from tomoscan.esrf.scan.utils import get_data
+from tomoscan.io import HDF5File
+
+import tomwer.version
 from tomwer.core.process.reconstruction.nabu.nabucommon import (
-    ResultSlurmRun,
     ResultsLocalRun,
+    ResultSlurmRun,
+    ResultsRun,
     ResultsWithStd,
 )
-from tomwer.core.scan.scanfactory import ScanFactory
-from .params import SADeltaBetaParams
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils import logconfig
-from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.io import HDF5File
-from tomoscan.esrf.scan.utils import get_data
-import tomwer.version
 from tomwer.core.process.reconstruction.nabu.nabuslices import (
+    SingleSliceRunner,
     run_single_slice_reconstruction,
 )
-from tomwer.core.process.reconstruction.nabu.nabucommon import ResultsRun
+from tomwer.core.process.reconstruction.scores import (
+    ComputedScore,
+    ScoreMethod,
+    apply_roi,
+    compute_score,
+    get_disk_mask_radius,
+)
+from tomwer.core.process.task import Task
 from tomwer.core.progress import Progress
-from ..nabu import utils as nabu_utils
-from tomwer.core.process.reconstruction.scores import compute_score
-from tomwer.core.process.reconstruction.scores import ScoreMethod
-from tomwer.core.process.reconstruction.scores import ComputedScore
-from tomwer.core.process.reconstruction.scores import get_disk_mask_radius, apply_roi
-from tomwer.core.process.reconstruction.nabu.nabuslices import SingleSliceRunner
-from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils import logconfig
 from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.volume.volumefactory import VolumeFactory
+
+from ..nabu import utils as nabu_utils
+from .params import SADeltaBetaParams
 
 _logger = logging.getLogger(__name__)
 
@@ -113,22 +119,20 @@ def one_slice_several_db(
     dry_run = configuration.dry_run
     cluster_config = configuration.cluster_config
     _logger.info(
-        "launch reconstruction of slice {} and delta / beta: {}".format(
-            slice_index, delta_beta_s
-        )
+        f"launch reconstruction of slice {slice_index} and delta / beta: {delta_beta_s}"
     )
     if isinstance(slice_index, str):
         if not slice_index == "middle":
-            raise ValueError("slice index {} not recognized".format(slice_index))
+            raise ValueError(f"slice index {slice_index} not recognized")
     elif not len(slice_index) == 1:
         raise ValueError("only manage one slice")
     else:
         slice_index = list(slice_index.values())[0]
-    advancement = Progress("sa-delta-beta - slice {} of {}".format(slice_index, scan))
+    advancement = Progress(f"sa-delta-beta - slice {slice_index} of {scan}")
 
     config = configuration.nabu_params.copy()
 
-    _logger.info("start reconstruction of {}".format(str(scan)))
+    _logger.info(f"start reconstruction of {scan}")
     # if scan contains some center of position copy it to nabu
     if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
         if "reconstruction" in config:
@@ -136,7 +140,7 @@ def one_slice_several_db(
             cor_nabu_ref = scan.axis_params.relative_cor_value + scan.dim_1 / 2.0
             config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
 
-    _logger.info("set nabu reconstruction parameters to {}".format(str(scan)))
+    _logger.info(f"set nabu reconstruction parameters to {scan}")
     scan.nabu_recons_params = config
 
     db_reconstructions = {}
@@ -285,8 +289,7 @@ def one_slice_several_db(
                     data = get_data(slice_url)
                 except Exception as e:
                     _logger.error(
-                        "Fail to compute a score for {}. Reason is {}"
-                        "".format(volume_identifier, str(e))
+                        f"Fail to compute a score for {volume_identifier}. Reason is {e}"
                     )
                     datasets_[db] = (slice_url, None)
                 else:
@@ -297,14 +300,12 @@ def one_slice_several_db(
                             data = data.reshape(data.shape[0], data.shape[1])
                         else:
                             raise ValueError(
-                                "Data is expected to be 2D. Not {}".format(data.ndim)
+                                f"Data is expected to be 2D. Not {data.ndim}D"
                             )
                     elif data.ndim == 2:
                         pass
                     else:
-                        raise ValueError(
-                            "Data is expected to be 2D. Not {}".format(data.ndim)
-                        )
+                        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
 
                     datasets_[db] = (slice_url, data)
             return datasets_
@@ -411,9 +412,7 @@ class SADeltaBetaProcess(
         elif isinstance(scan, dict):
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
         # insure scan contains some parameter regarding sa delta / beta
         if scan.sa_delta_beta_params is None:
             scan.sa_delta_beta_params = SADeltaBetaParams()
@@ -458,18 +457,13 @@ class SADeltaBetaProcess(
             slice_index = self.get_configuration().get("slice_index", None)
 
             if db_res is None:
-                info = (
-                    "fail to compute delta/beta scores of slice {} for scan {}."
-                    "".format(slice_index, scan)
-                )
+                info = f"fail to compute delta/beta scores of slice {slice_index} for scan {scan}."
                 _logger.processFailed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan, process=self, state=DatasetState.FAILED, details=info
                 )
             else:
-                info = "delta/beta scores of slice {} for scan {} computed." "".format(
-                    slice_index, scan
-                )
+                info = f"delta/beta scores of slice {slice_index} for scan {scan} computed."
                 _logger.processSucceed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan,
@@ -496,7 +490,7 @@ class SADeltaBetaProcess(
         if not isinstance(score_rois, dict):
             raise TypeError("score_rois is expected to be a dict")
         process_file = scan.process_file
-        process_name = "tomwer_process_" + str(process_index)
+        process_name = f"tomwer_process_{process_index}"
 
         if scan.saaxis_params.scores in (None, {}):
             return

tomwer/core/process/reconstruction/scores/__init__.py

@@ -1,6 +1,6 @@
-from .scores import ScoreMethod  # noqa F401
 from .params import SABaseParams  # noqa F401
-from .scores import compute_score  # noqa F401
 from .scores import ComputedScore  # noqa F401
+from .scores import ScoreMethod  # noqa F401
 from .scores import apply_roi  # noqa F401
+from .scores import compute_score  # noqa F401
 from .scores import get_disk_mask_radius  # noqa F401

tomwer/core/process/reconstruction/scores/params.py

@@ -28,10 +28,11 @@ __license__ = "MIT"
 __date__ = "04/05/2021"
 
 
-from tomwer.core.cluster.cluster import SlurmClusterConfiguration
-from tomwer.core.process.reconstruction.scores import ScoreMethod
 from typing import Optional, Union
 
+from tomwer.core.cluster.cluster import SlurmClusterConfiguration
+from tomwer.core.process.reconstruction.scores.scores import ScoreMethod
+
 
 class SABaseParams:
     """Parameters for the semi-automatic axis calculation"""
@@ -79,8 +80,7 @@ class SABaseParams:
                 raise ValueError("the only valid indexes values is 'middle'")
         elif not isinstance(indexes, (type(None), dict)):
             raise TypeError(
-                "index should be an instance of int or None and "
-                "not {}".format(type(indexes))
+                f"index should be an instance of int or None and not {type(indexes)}"
             )
         self._slice_indexes = indexes
 
@@ -91,9 +91,7 @@ class SABaseParams:
     @nabu_params.setter
     def nabu_params(self, params: dict):
         if not isinstance(params, dict):
-            raise TypeError(
-                "params should be a dictionary and not {}" "".format(type(params))
-            )
+            raise TypeError(f"params should be a dictionary and not {type(params)}")
         self._nabu_params = params
 
     @property
@@ -144,8 +142,7 @@ class SABaseParams:
             raise TypeError("format should be a str")
         if format_ not in self._VALID_FILE_FORMAT:
             raise ValueError(
-                "requested format ({}) is invalid. valid ones "
-                "are {}".format(format_, self._VALID_FILE_FORMAT)
+                f"requested format ({format_}) is invalid. valid ones are {self._VALID_FILE_FORMAT}"
             )
         self._file_format = format_
 

tomwer/core/process/reconstruction/scores/scores.py

@@ -28,12 +28,13 @@ __license__ = "MIT"
 __date__ = "18/02/2021"
 
 
-from silx.utils.enum import Enum as _Enum
-import numpy
-import sys
 import logging
+import sys
 from typing import Union
 
+import numpy
+from silx.utils.enum import Enum as _Enum
+
 _logger = logging.getLogger(__name__)
 
 
@@ -76,7 +77,7 @@ class ComputedScore:
         elif method is ScoreMethod.TOMO_CONSISTENCY:
             return self.tomo_consistency
         else:
-            raise ValueError("{} is an unrecognized method".format(method))
+            raise ValueError(f"{method} is an unrecognized method")
 
 
 def compute_tomo_consistency(
@@ -160,11 +161,11 @@ def compute_score(
         elif data.shape[2] == 1:
             data = data.reshape(data.shape[0], data.shape[1])
         else:
-            raise ValueError("Data is expected to be 2D. Not {}".format(data.ndim))
+            raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
     elif data.ndim == 2:
         pass
     else:
-        raise ValueError("Data is expected to be 2D. Not {}".format(data.ndim))
+        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
     if method is ScoreMethod.TOMO_CONSISTENCY:
         try:
             return compute_tomo_consistency(
@@ -177,9 +178,7 @@ def compute_score(
         except ImportError:
             return None
         except Exception as e:
-            _logger.warning(
-                "Fail to compute 'tomo consistency' score. " "Reason is {}".format(e)
-            )
+            _logger.warning(f"Fail to compute 'tomo consistency' score. Reason is {e}")
             return None
     else:
         fct = _METHOD_TO_FCT.get(method, None)
@@ -187,7 +186,7 @@ def compute_score(
     if fct is not None:
         return fct(data)
     else:
-        raise ValueError("{} is not handled".format(method))
+        raise ValueError(f"{method} is not handled")
 
 
 def get_disk_mask_radius(datasets_) -> int:
@@ -214,7 +213,5 @@ def apply_roi(data, radius, url) -> numpy.array:
     try:
         return data[min_y:max_y, min_x:max_x]
     except Exception:
-        _logger.error(
-            "Fail to apply roi for {}. Take the entire dataset".format(url.path())
-        )
+        _logger.error(f"Fail to apply roi for {url.path()}. Take the entire dataset")
         return data

tomwer/core/process/reconstruction/test/test_axis_params.py

@@ -1,11 +1,13 @@
 import os
+
+import numpy
 import pytest
+
 from tomwer.core.process.reconstruction.axis.params import (
-    AxisResource,
     AxisCalculationInput,
+    AxisResource,
 )
 from tomwer.core.utils.scanutils import MockHDF5
-import numpy
 
 
 def test_axis_resource(tmp_path):

tomwer/core/process/reconstruction/test/test_darkref.py

@@ -28,11 +28,10 @@ __license__ = "MIT"
 __date__ = "24/11/2021"
 
 
-from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.utils.scanutils import MockHDF5
 from tomwer.core.process.reconstruction.darkref.darkrefs import (
     requires_reduced_dark_and_flat,
 )
+from tomwer.core.utils.scanutils import MockEDF, MockHDF5
 
 
 def test_quick_run_necessary_edf(tmpdir):

tomwer/core/process/reconstruction/test/test_darkref_copy.py

@@ -1,7 +1,9 @@
 import os
+
 import numpy
 import pytest
 from silx.io.dictdump import dicttoh5
+
 from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
 from tomwer.core.utils.scanutils import MockHDF5
 
@@ -91,8 +93,8 @@ def test_save_reduced_frames_to_be_copied(tmp_path):
     test save_flats_to_be_copied and save_darks_to_be_copied functions
     """
     # create raw data
-    from tomoscan.scanbase import ReducedFramesInfos
     from silx.io.url import DataUrl
+    from tomoscan.scanbase import ReducedFramesInfos
 
     raw_data = tmp_path / "raw_data"
     raw_data.mkdir()

tomwer/core/process/reconstruction/test/test_paramsbase.py

@@ -1,5 +1,5 @@
-from tomwer.core.process.reconstruction.paramsbase import _ReconsParam, _get_db_fromstr
 from tomwer.core.process.reconstruction.darkref.params import DKRFRP
+from tomwer.core.process.reconstruction.paramsbase import _get_db_fromstr, _ReconsParam
 
 
 def test_paramsbase():

tomwer/core/process/reconstruction/test/test_saaxis.py

@@ -28,17 +28,21 @@ __license__ = "MIT"
 __date__ = "27/02/2021"
 
 
-import unittest
-from tomwer.core.process.reconstruction.scores.scores import compute_score_contrast_std
-from tomwer.core.process.reconstruction.scores.scores import _METHOD_TO_FCT
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
-from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-from tomwer.core.utils.scanutils import MockHDF5
 import os
-import tempfile
 import shutil
+import tempfile
+import unittest
+
 import numpy
 
+from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
+from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
+from tomwer.core.process.reconstruction.scores.scores import (
+    _METHOD_TO_FCT,
+    compute_score_contrast_std,
+)
+from tomwer.core.utils.scanutils import MockHDF5
+
 
 class TestScoreFunctions(unittest.TestCase):
     """Test all the score functions"""

tomwer/core/process/reconstruction/test/test_sadeltabeta.py

@@ -28,15 +28,16 @@ __license__ = "MIT"
 __date__ = "27/02/2021"
 
 
+import os
+import shutil
+import tempfile
 import unittest
+
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
-    SADeltaBetaProcess,
     SADeltaBetaParams,
+    SADeltaBetaProcess,
 )
 from tomwer.core.utils.scanutils import MockHDF5
-import os
-import tempfile
-import shutil
 
 
 class TestSADeltaBetaProcess(unittest.TestCase):