tomwer 1.1.1__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -34,23 +34,26 @@ __license__ = "MIT"
 __date__ = "26/02/2021"
 
 
-from tomwer.gui import icons
-from tomwer.core.process.reconstruction.saaxis.saaxis import ReconstructionMode
-from tomwer.gui.utils.slider import LogSlider
-from tomwer.core.scan.scanbase import TomwerScanBase
+import functools
+import logging
+import weakref
 from typing import Union
+
+import numpy
+from silx.gui import icons as silxicons
+from silx.gui import qt
+from silx.gui.dialog.ImageFileDialog import ImageFileDialog
 from silx.gui.plot import items
 from silx.utils.enum import Enum as _Enum
+from tomoscan.esrf.scan.utils import get_data
+
+from tomwer.core.process.reconstruction.saaxis.saaxis import ReconstructionMode
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.gui import icons
 from tomwer.gui.reconstruction.saaxis.sliceselector import SliceSelector
-from tomwer.gui.visualization.sinogramviewer import SinogramViewer as _SinogramViewer
 from tomwer.gui.utils.lineselector import QSliceSelectorDialog
-from silx.gui import qt, icons as silxicons
-from silx.gui.dialog.ImageFileDialog import ImageFileDialog
-from tomoscan.esrf.scan.utils import get_data
-import numpy
-import weakref
-import logging
-import functools
+from tomwer.gui.utils.slider import LogSlider
+from tomwer.gui.visualization.sinogramviewer import SinogramViewer as _SinogramViewer
 
 _logger = logging.getLogger(__name__)
 
@@ -124,13 +127,13 @@ class SinogramViewer(_SinogramViewer):
             and self._estimated_cor is not None
         ):
             self.setCorRange(
-                min=self._min,
-                max=self._max,
+                cor_min=self._min,
+                cor_max=self._max,
                 estimated_cor=self._estimated_cor,
                 other_cors=self._other_cors,
             )
 
-    def setCorRange(self, min, max, estimated_cor, other_cors=tuple()):
+    def setCorRange(self, cor_min, cor_max, estimated_cor, other_cors=tuple()):
         """
         For now we can only modify the estimated cor
 
@@ -140,8 +143,8 @@ class SinogramViewer(_SinogramViewer):
         :param int display_n_recons: the grid created by all cor observe
         :return:
         """
-        self._min = min
-        self._max = max
+        self._min = cor_min
+        self._max = cor_max
         self._estimated_cor = estimated_cor
         self._other_cors = other_cors if other_cors is not None else tuple()
 
@@ -168,10 +171,10 @@ class SinogramViewer(_SinogramViewer):
             plot.removeMarker(marker)
         # recreate markers
         plot.addXMarker(
-            x=min, legend="from", text="from", color="#3449ebff", draggable=True
+            x=cor_min, legend="from", text="from", color="#3449ebff", draggable=True
         )
         plot.addXMarker(
-            x=max, legend="to", text="to", color="#3449ebff", draggable=True
+            x=cor_max, legend="to", text="to", color="#3449ebff", draggable=True
         )
         plot.addXMarker(
             x=estimated_cor,
@@ -182,7 +185,7 @@ class SinogramViewer(_SinogramViewer):
         )
         for i_cor, cor in enumerate(other_cors):
             plot.addXMarker(
-                x=cor, legend="cor_{}".format(i_cor), draggable=False, color="#34dceb42"
+                x=cor, legend=f"cor_{i_cor}", draggable=False, color="#34dceb42"
             )
 
         # handle draggable markers
@@ -274,15 +277,13 @@ class _ReconstructionModeGB(qt.QGroupBox):
         valid_modes = ("vertical", "horizontal")
         if mode not in valid_modes:
             raise ValueError(
-                "mode {} is not recosgnized. Valid modes are {}"
-                "".format(mode, valid_modes)
+                f"mode {mode} is not recosgnized. Valid modes are {valid_modes}"
             )
         self._verticalRB.setChecked(mode == "vertical")
         if mode == "vertical":
             if slices not in self._DEFAULT_VERTICAL_SLICE_MODE:
                 raise ValueError(
-                    "{} is not a vadid slice mode. Calid are {}"
-                    "".format(slices, self._DEFAULT_VERTICAL_SLICE_MODE)
+                    f"{slices} is not a vadid slice mode. Calid are {self._DEFAULT_VERTICAL_SLICE_MODE}"
                 )
             else:
                 index = self._defaultSlicesCB.findText(slices)
@@ -358,29 +359,29 @@ class _ReconstructionModeGB(qt.QGroupBox):
             else:
                 return self._sliceVerticalQSB.getSlicesValue()
         else:
-            raise ValueError("mode {} is not handled".format(mode))
+            raise ValueError(f"mode {mode} is not handled")
 
-    def setReconstructionSlices(self, slice: Union[dict, int, str]):
+    def setReconstructionSlices(self, slice_: Union[dict, int, str]):
         slice_name = None
-        if slice == "middle" or isinstance(slice, int) or len(slice) == 1:
+        if slice_ == "middle" or isinstance(slice_, int) or len(slice_) == 1:
             self.setReconstructionMode(ReconstructionMode.VERTICAL)
             target = self._sliceVerticalQSB
-            if slice == "middle":
+            if slice_ == "middle":
                 index = self._defaultSlicesCB.findText("middle")
             else:
                 index = self._defaultSlicesCB.findText("other")
                 slice_name = "Slice"
             self._defaultSlicesCB.setCurrentIndex(index)
-        elif len(slice) == 2:
+        elif len(slice_) == 2:
             self.setReconstructionMode(ReconstructionMode.TILT_CORRECTION)
             target = self._sliceTiltCorrQSB
         else:
             raise ValueError("slice is expected to contain one or two element(s)")
-        if slice not in ("middle",):
-            if isinstance(slice, int):
-                target.setSliceValue(name=slice_name, value=slice)
+        if slice_ not in ("middle",):
+            if isinstance(slice_, int):
+                target.setSliceValue(name=slice_name, value=slice_)
             else:
-                for slice_name, slice_value in slice.items():
+                for slice_name, slice_value in slice_.items():
                     target.setSliceValue(name=slice_name, value=slice_value)
 
     def _reconstructionModeChanged(self, *args, **kwargs):
@@ -534,14 +535,14 @@ class _EstimatedCorWidget(qt.QGroupBox):
                 else:
                     return self._MIDDLE_COR_TXT
             else:
-                raise ValueError("Mode {} is not recognized".format(mode))
+                raise ValueError(f"Mode {mode} is not recognized")
         else:
             if mode in ("rel", "relative"):
                 return self._manualCORRel.value()
             elif mode in ("abs", "absolute"):
                 return self._manualCORAbs.value()
             else:
-                raise ValueError("Mode {} is not recognized".format(mode))
+                raise ValueError(f"Mode {mode} is not recognized")
 
     def _modeChanged(self, *args, **kwargs):
         manual_opt_visible = not self._middlePositionRB.isChecked()

tomwer/gui/reconstruction/saaxis/dimensionwidget.py

@@ -34,9 +34,10 @@ __license__ = "MIT"
 __date__ = "05/02/2021"
 
 
+from collections.abc import Iterable
+
 from silx.gui import qt
 from tomoscan.unitsystem import metricsystem
-from collections.abc import Iterable
 
 
 class DimensionWidget(qt.QGroupBox):
@@ -85,7 +86,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim0ValueQLE.setSingleStep(0.0001)
         self._dim0ValueQLE.setValue(self._getDim0DisplayValue())
         if dims_colors is not None:
-            stylesheet = "background-color: {}".format(dims_colors[0])
+            stylesheet = f"background-color: {dims_colors[0]}"
             self._dim0ValueQLE.setStyleSheet(stylesheet)
         self.layout().addWidget(self._dim0ValueQLE)
         # dim 1
@@ -97,7 +98,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim1ValueQLE.setSingleStep(0.0001)
         self._dim1ValueQLE.setValue(self._getDim1DisplayValue())
         if dims_colors is not None:
-            stylesheet = "background-color: {}".format(dims_colors[1])
+            stylesheet = f"background-color: {dims_colors[1]}"
             self._dim1ValueQLE.setStyleSheet(stylesheet)
         self.layout().addWidget(self._dim1ValueQLE)
         # dim 2
@@ -109,7 +110,7 @@ class DimensionWidget(qt.QGroupBox):
         self._dim2ValueQLE.setSingleStep(0.0001)
         self._dim2ValueQLE.setValue(self._getDim2DisplayValue())
         if dims_colors is not None:
-            stylesheet = "background-color: {}".format(dims_colors[2])
+            stylesheet = f"background-color: {dims_colors[2]}"
             self._dim2ValueQLE.setStyleSheet(stylesheet)
         self.layout().addWidget(self._dim2ValueQLE)
 

tomwer/gui/reconstruction/saaxis/saaxis.py

@@ -34,25 +34,26 @@ __license__ = "MIT"
 __date__ = "01/02/2021"
 
 
+import logging
+from typing import Union
+
+import numpy
 from silx.gui import qt
-from tomwer.gui import icons
-from tomwer.gui.reconstruction.nabu.slices import NabuWindow
-from tomwer.gui.reconstruction.axis.radioaxis import _CalculationWidget
-from tomwer.synctools.axis import QAxisRP
+
+from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
 from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-from tomwer.gui.reconstruction.scores.scoreplot import ScorePlot as _ScorePlot
-from tomwer.gui.reconstruction.scores.scoreplot import CorSelection
+from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
+from tomwer.gui import icons
+from tomwer.gui.reconstruction.axis.radioaxis import _CalculationWidget
+from tomwer.gui.reconstruction.nabu.slices import NabuWindow
 from tomwer.gui.reconstruction.saaxis.corrangeselector import SliceAndCorWidget
-from tomwer.gui.utils.buttons import TabBrowsersButtons
 from tomwer.gui.reconstruction.scores.control import ControlWidget
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
-from tomwer.core.process.reconstruction.axis import mode as axis_mode
+from tomwer.gui.reconstruction.scores.scoreplot import CorSelection
+from tomwer.gui.reconstruction.scores.scoreplot import ScorePlot as _ScorePlot
+from tomwer.gui.utils.buttons import TabBrowsersButtons
 from tomwer.gui.utils.scandescription import ScanNameLabelAndShape
-import numpy
-from typing import Union
-import logging
-
+from tomwer.synctools.axis import QAxisRP
 
 _logger = logging.getLogger(__file__)
 
@@ -264,8 +265,7 @@ class _SAAxisTabWidget(qt.QTabWidget):
             config = config.to_dict()
         if not isinstance(config, dict):
             raise TypeError(
-                "config should be a dictionary or a SAAxisParams. "
-                "Not {}".format(type(config))
+                f"config should be a dictionary or a SAAxisParams. Not {type(config)}"
             )
 
         research_width = config.get("research_width", None)
@@ -491,8 +491,8 @@ class SAAxisWindow(qt.QMainWindow):
         else:
             other_cors = ()
         sino_viewer.setCorRange(
-            min=cors[0],
-            max=cors[-1],
+            cor_min=cors[0],
+            cor_max=cors[-1],
             estimated_cor=estimated_cor,
             other_cors=other_cors,
         )

tomwer/gui/reconstruction/saaxis/sliceselector.py

@@ -35,11 +35,11 @@ __license__ = "MIT"
 __date__ = "04/02/2021"
 
 
-from silx.gui import qt
-from silx.gui.plot import PlotWidget
 import functools
-import numpy
 
+import numpy
+from silx.gui import qt
+from silx.gui.plot import PlotWidget
 
 # class SliceSelectorWithMiddle(qt.QWidget):
 
@@ -82,7 +82,7 @@ class SliceSelector(qt.QWidget):
         widget.layout().setContentsMargins(0, 0, 0, 0)
         widget.layout().addWidget(qt.QLabel(name, self))
         sb = qt.QSpinBox(self)
-        stylesheet = "background-color: {}".format(color)
+        stylesheet = f"background-color: {color}"
         sb.setStyleSheet(stylesheet)
 
         min_i, max_i = self.getSlicesRange()
@@ -288,7 +288,7 @@ class _SliceSelectorFrmVolume(PlotWidget):
         self.sigSlicesChanged.emit()
 
     def getMarkerName(self, name: str):
-        return "marker_{}".format(name)
+        return f"marker_{name}"
 
     def _addSliceAnchor(self, value, curve_name, color):
         y_value = self.valueToPlotSpace(value=value)

tomwer/gui/reconstruction/sadeltabeta/saadeltabeta.py

@@ -34,28 +34,32 @@ __license__ = "MIT"
 __date__ = "20/05/2021"
 
 
+import logging
+import typing
+
+import numpy
 from silx.gui import qt
-from tomwer.gui import icons
-from tomwer.core.process.reconstruction.scores.params import ScoreMethod
+
+from tomwer.core.process.reconstruction.nabu.utils import (
+    ConfigurationLevel,
+    _NabuMode,
+    retrieve_lst_of_value_from_str,
+)
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaProcess,
 )
-from tomwer.synctools.sadeltabeta import QSADeltaBetaParams
-from tomwer.gui.utils.buttons import TabBrowsersButtons
+from tomwer.core.process.reconstruction.scores.params import ScoreMethod
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.gui import icons
+from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
 from tomwer.gui.reconstruction.nabu.slices import NabuWindow
-from tomwer.gui.utils.scandescription import ScanNameLabelAndShape
-from tomwer.gui.reconstruction.scores.scoreplot import ScorePlot as _ScorePlot
-from tomwer.gui.reconstruction.scores.scoreplot import DelaBetaSelection
-from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
-from tomwer.core.process.reconstruction.nabu.utils import ConfigurationLevel
-from tomwer.core.process.reconstruction.nabu.utils import retrieve_lst_of_value_from_str
-from tomwer.gui.reconstruction.scores.control import ControlWidget
 from tomwer.gui.reconstruction.saaxis.sliceselector import SliceSelector
-from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
-from tomwer.core.scan.scanbase import TomwerScanBase
-import typing
-import numpy
-import logging
+from tomwer.gui.reconstruction.scores.control import ControlWidget
+from tomwer.gui.reconstruction.scores.scoreplot import DelaBetaSelection
+from tomwer.gui.reconstruction.scores.scoreplot import ScorePlot as _ScorePlot
+from tomwer.gui.utils.buttons import TabBrowsersButtons
+from tomwer.gui.utils.scandescription import ScanNameLabelAndShape
+from tomwer.synctools.sadeltabeta import QSADeltaBetaParams
 
 _logger = logging.getLogger(__name__)
 
@@ -181,16 +185,15 @@ class _SADeltaBetaTabWidget(qt.QTabWidget):
     def getReconstructionSlice(self):
         return self._deltaBetaSelectionWidget.getSlice()
 
-    def setReconstructionSlice(self, slice):
-        return self._deltaBetaSelectionWidget.setSlice(slice=slice)
+    def setReconstructionSlice(self, slice_):
+        return self._deltaBetaSelectionWidget.setSlice(slice_=slice_)
 
     def setConfiguration(self, config):
         if isinstance(config, QSADeltaBetaParams):
             config = config.to_dict()
         if not isinstance(config, dict):
             raise TypeError(
-                "config should be a dictionary or a SAAxisParams. "
-                "Not {}".format(type(config))
+                f"config should be a dictionary or a SAAxisParams. Not {type(config)}"
             )
 
         db_values = config.get("delta_beta_values", None)
@@ -429,24 +432,20 @@ class DeltaBetaSelectionWidget(qt.QWidget):
     def _updated(self, *args, **kwargs):
         self.sigConfigurationChanged.emit()
 
-    def setSlice(self, slice: typing.Union["str", int]):
-        if isinstance(slice, str):
-            if slice != "middle":
-                raise ValueError(
-                    "Slice should be 'middle' or an int. " "Not {}".format(slice)
-                )
+    def setSlice(self, slice_: typing.Union["str", int]):
+        if isinstance(slice_, str):
+            if slice_ != "middle":
+                raise ValueError(f"Slice should be 'middle' or an int. Not {slice_}")
             else:
                 self.setMode("middle")
-        elif isinstance(slice, int):
+        elif isinstance(slice_, int):
             self.setMode("other")
-            self._sliceSelectionQSB.setSliceValue("Slice", slice)
-        elif isinstance(slice, dict) and "Slice" in slice:
+            self._sliceSelectionQSB.setSliceValue("Slice", slice_)
+        elif isinstance(slice_, dict) and "Slice" in slice_:
             self.setMode("other")
-            self._sliceSelectionQSB.setSliceValue("Slice", slice["Slice"])
+            self._sliceSelectionQSB.setSliceValue("Slice", slice_["Slice"])
         else:
-            raise TypeError(
-                "slice should be an int or 'middle'. Not {}".format(type(slice))
-            )
+            raise TypeError(f"slice should be an int or 'middle'. Not {type(slice_)}")
 
     def setSliceRange(self, min_, max_):
         self._sliceSelectionQSB.setSlicesRange(min_, max_)
@@ -457,9 +456,7 @@ class DeltaBetaSelectionWidget(qt.QWidget):
     def setMode(self, mode):
         if mode not in self._DEFAULT_VERTICAL_SLICE_MODE:
             raise ValueError(
-                "mode should be in {}. Not {}.".format(
-                    self._DEFAULT_VERTICAL_SLICE_MODE, mode
-                )
+                f"mode should be in {self._DEFAULT_VERTICAL_SLICE_MODE}. Not {mode}."
             )
         idx = self._defaultSlicesCB.findText(mode)
         self._defaultSlicesCB.setCurrentIndex(idx)

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -35,25 +35,26 @@ __license__ = "MIT"
 __date__ = "25/02/2021"
 
 
+import logging
 import os
 import weakref
-import numpy
-import logging
-from typing import Union
 from contextlib import AbstractContextManager
+from typing import Union
+
+import numpy
 from matplotlib import image as _matplotlib_image
 from silx.gui import qt
 from silx.gui.plot import PlotWidget
-from tomwer.io.utils.utils import get_slice_data
+
+from tomwer.core.process.reconstruction.scores.params import ScoreMethod
+from tomwer.gui import icons, settings
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
-from tomwer.gui.visualization.dataviewer import ImageStack
-from tomwer.gui.utils.vignettes import VignettesQDialog
 from tomwer.gui.utils.buttons import PadlockButton
-from tomwer.gui import icons
-from tomwer.gui import settings
-from tomwer.io.utils.h5pyutils import DatasetReader
-from tomwer.core.process.reconstruction.scores.params import ScoreMethod
+from tomwer.gui.utils.vignettes import VignettesQDialog
+from tomwer.gui.visualization.dataviewer import ImageStack
 from tomwer.io.utils import get_default_directory
+from tomwer.io.utils.h5pyutils import DatasetReader
+from tomwer.io.utils.utils import get_slice_data
 
 _logger = logging.getLogger(__name__)
 
@@ -147,7 +148,7 @@ class VariableSelection(qt.QWidget):
         # TODO: this should be inherite by a cor plot (to display variable and absloute value)
         # cor value
         self._currentVarValue = qt.QGroupBox(self)
-        self._currentVarValue.setTitle("current {} value".format(self._variable_name))
+        self._currentVarValue.setTitle(f"current {self._variable_name} value")
         self._currentVarValue.setLayout(qt.QFormLayout())
         self.layout().addWidget(self._currentVarValue, 0, 3, 3, 2)
 
@@ -156,7 +157,7 @@ class VariableSelection(qt.QWidget):
         self.layout().addWidget(self._currentcorRB, 0, 5, 1, 1)
         self._autofocusRB = qt.QRadioButton("autofocus", self)
         self._autofocusRB.setToolTip(
-            "Take the {} with the best score".format(self._variable_name)
+            f"Take the {self._variable_name} with the best score"
         )
         self.layout().addWidget(self._autofocusRB, 1, 5, 1, 1)
         # lock autofocus button
@@ -211,13 +212,13 @@ class VariableSelection(qt.QWidget):
             master_plot = self.parent().getPlotWidget()
             colormap = master_plot.getColorBarWidget().getColormap()
         dialog = VignettesQDialog(
-            value_name="{} position".format(self._variable_name),
+            value_name=f"{self._variable_name} position",
             score_name="score",
             value_format="{:.3f}",
             score_format="{:.3f}",
             colormap=colormap,
         )
-        dialog.setWindowTitle("{} - vignettes".format(self.getWindowTitle()))
+        dialog.setWindowTitle(f"{self.getWindowTitle()} - vignettes")
 
         # set scores
         dialog.setScores(self._scores, score_method=self.getScoreMethod())
@@ -285,7 +286,7 @@ class SingleValueSelection(VariableSelection):
         self._currentVarValue.layout().addRow("value:", self._valueLE)
 
     def setValue(self, value):
-        self._valueLE.setText("{:.2f}".format(value))
+        self._valueLE.setText(f"{value:.2f}")
 
     def getWindowTitle(self):
         raise NotImplementedError("Base class")
@@ -325,12 +326,12 @@ class CorSelection(VariableSelection):
         if relative_value is None:
             self._relativeVarValueLE.clear()
         else:
-            self._relativeVarValueLE.setText("{:.3f}".format(relative_value))
+            self._relativeVarValueLE.setText(f"{relative_value:.3f}")
         if relative_value is None or self._img_width is None:
             self._absoluteVarValueLE.clear()
         else:
             absolute_value = relative_value + self._img_width / 2.0
-            self._absoluteVarValueLE.setText("{:.3f}".format(absolute_value))
+            self._absoluteVarValueLE.setText(f"{absolute_value:.3f}")
 
     def getWindowTitle(self):
         return "sa axis - vignettes"
@@ -439,7 +440,7 @@ class _VariableValueLabels(qt.QWidget):
         for i_var in var_indexes:
             var_value = self._var_values[i_var]
             var_px_pos = var_px_positions[i_var]
-            txt_value = "{:.3f}".format(var_value)
+            txt_value = f"{var_value:.3f}"
             # apply rotation to "invert" the painter rotation requested to
             # paint oblique text
             with PainterRotationCM(

tomwer/gui/reconstruction/test/test_axis.py

@@ -27,22 +27,23 @@ __license__ = "MIT"
 __date__ = "16/06/2021"
 
 
-from tomwer.gui.reconstruction.axis import AxisWindow
-from tomwer.gui.reconstruction.axis.radioaxis import _ManualFramesSelection
-from tomwer.tests.utils import skip_gui_test
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.synctools.axis import QAxisRP
-from silx.gui.utils.testutils import TestCaseQt
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from silx.gui import qt
-import numpy.random
-import pytest
-import tempfile
 import os
 import shutil
+import tempfile
+
 import h5py
+import numpy.random
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.gui.reconstruction.axis import AxisWindow
+from tomwer.gui.reconstruction.axis.radioaxis import _ManualFramesSelection
+from tomwer.synctools.axis import QAxisRP
+from tomwer.tests.utils import UtilsTest, skip_gui_test
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")

tomwer/gui/reconstruction/test/test_lamino.py

@@ -31,12 +31,13 @@ import os
 import shutil
 import tempfile
 import unittest
+
 import pytest
 from silx.gui import qt
+
 from tomwer.core import settings
 from tomwer.gui.reconstruction.lamino.tofu import TofuWindow
-from tomwer.tests.utils import UtilsTest
-from tomwer.tests.utils import skip_gui_test
+from tomwer.tests.utils import UtilsTest, skip_gui_test
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")

tomwer/gui/reconstruction/test/test_nabu.py

@@ -28,21 +28,23 @@ __date__ = "05/02/2020"
 
 
 import os
+
+import pytest
 from silx.gui import qt
-from tomwer.tests.utils import skip_gui_test
-from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.reconstruction.nabu.nabuconfig.output import _NabuOutputConfig
+from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.preprocessing import (
     _NabuPreProcessingConfig,
     _RingCorrectionMethod,
 )
-from tomwer.gui.reconstruction.nabu.nabuconfig.phase import _NabuPhaseConfig
 from tomwer.gui.reconstruction.nabu.nabuconfig.reconstruction import (
     _NabuReconstructionConfig,
 )
-from tomwer.gui.reconstruction.nabu.nabuconfig.output import _NabuOutputConfig
+from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
 from tomwer.gui.reconstruction.nabu.volume import NabuVolumeWidget
-from silx.gui.utils.testutils import TestCaseQt
-import pytest
+from tomwer.tests.utils import skip_gui_test
 
 
 class ProcessClass:

tomwer/gui/reconstruction/test/test_saaxis.py

@@ -27,26 +27,28 @@ __license__ = "MIT"
 __date__ = "03/02/2021"
 
 
-from tomwer.tests.utils import skip_gui_test
-from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
-from tomoscan.unitsystem import metricsystem
+import os
+import shutil
+import tempfile
+
+import h5py
+import numpy
+import pytest
+from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
-from tomwer.core.utils.scanutils import MockHDF5
-from tomwer.gui.reconstruction.saaxis.saaxis import SAAxisWindow
+from silx.io.url import DataUrl
+from tomoscan.unitsystem import metricsystem
+
 from tomwer.core.process.reconstruction.saaxis.params import (
-    SAAxisParams,
     ReconstructionMode,
+    SAAxisParams,
 )
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from silx.io.url import DataUrl
-from silx.gui import qt
-import pytest
-import numpy
-import shutil
-import tempfile
-import os
-import h5py
+from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
+from tomwer.gui.reconstruction.saaxis.saaxis import SAAxisWindow
+from tomwer.tests.utils import skip_gui_test
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
@@ -127,7 +129,7 @@ class TestSAAxisWindow(TestCaseQt):
         self._cor_scores = {}
 
         for i in range(self._N_OUTPUT_URLS):
-            output_file = os.path.join(self.folder, "recons_{}.h5".format(i))
+            output_file = os.path.join(self.folder, f"recons_{i}.h5")
             with h5py.File(output_file, mode="a") as h5f:
                 h5f["data"] = numpy.random.random(100 * 100).reshape(100, 100)
                 url = DataUrl(file_path=output_file, data_path="data", scheme="silx")