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

tomwer/core/process/reconstruction/axis/axis.py

@@ -29,42 +29,43 @@ __authors__ = ["C.Nemoz", "H.Payno"]
 __license__ = "MIT"
 __date__ = "19/03/2019"
 
+import logging
+from typing import Optional, Union
+
 import nabu
 import numpy
-import logging
-from processview.core.manager import ProcessManager
-from processview.core.manager import DatasetState
+from nabu.estimation.cor import (
+    CenterOfRotation,
+    CenterOfRotationAdaptiveSearch,
+    CenterOfRotationGrowingWindow,
+    CenterOfRotationSlidingWindow,
+)
+from nabu.pipeline.estimators import SinoCORFinder
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+
 import tomwer.version
+from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
+from tomwer.core.process.task import Task
+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 image, logconfig
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.utils import docstring
+
+from .anglemode import CorAngleMode
+from .mode import AxisMode
 from .params import (
-    AxisRP,
-    DEFAULT_CMP_TAKE_LOG,
-    DEFAULT_CMP_OVERSAMPLING,
     DEFAULT_CMP_N_SUBSAMPLING_Y,
     DEFAULT_CMP_NEAR_POS,
     DEFAULT_CMP_NEAR_WIDTH,
+    DEFAULT_CMP_OVERSAMPLING,
+    DEFAULT_CMP_TAKE_LOG,
     DEFAULT_CMP_THETA,
+    AxisRP,
 )
-from .mode import AxisMode
 from .projectiontype import ProjectionType
-from .anglemode import CorAngleMode
-from tomwer.core.process.task import Task
-from processview.core.superviseprocess import SuperviseProcess
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.reconstruction.utils.cor import absolute_pos_to_relative
-from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.utils.scanutils import data_identifier_to_scan
-from tomwer.core.utils import logconfig
-from typing import Optional, Union
-from tomwer.utils import docstring
-from tomwer.core.utils import image
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from nabu.estimation.cor import (
-    CenterOfRotation,
-    CenterOfRotationAdaptiveSearch,
-    CenterOfRotationGrowingWindow,
-    CenterOfRotationSlidingWindow,
-)
-from nabu.pipeline.estimators import SinoCORFinder
 
 try:
     from nabu.pipeline.estimators import CompositeCOREstimator
@@ -73,8 +74,8 @@ except ImportError:
 else:
     has_composite_cor_finder = True
 from silx.io.url import DataUrl
-from tomoscan.io import HDF5File
 from silx.io.utils import h5py_read_dataset
+from tomoscan.io import HDF5File
 
 _logger = logging.getLogger(__name__)
 if not has_composite_cor_finder:
@@ -111,9 +112,10 @@ def adapt_tomwer_scan_to_nabu(scan: TomwerScanBase):
         # since this version nabu does not the load of dark / flat mean/median
         # directly in the function but outside. So we need an extra call to
         # update_dataset_info_flats_darks
-        from nabu.resources.nxflatfield import update_dataset_info_flats_darks
         import inspect
 
+        from nabu.resources.nxflatfield import update_dataset_info_flats_darks
+
         # processes_file has been removed in a minor release. safer to inspect if is needed or not
         # should be removed on release 1.1 of tomwer I guess
         if (
@@ -265,7 +267,7 @@ def compute_scan_composite_coarse_to_fine(scan: TomwerScanBase):
         cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
         logger=_logger,
         take_log=take_log,
-        **extra_args
+        **extra_args,
     )
     res = corfinder.find_cor()
     return _absolute_pos_to_relative_with_warning(
@@ -679,7 +681,7 @@ class AxisProcess(
         elif isinstance(scan, dict):
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
-            raise ValueError("input type {} is not managed".format(scan))
+            raise ValueError(f"input type {scan} is not managed")
 
         _logger.info("start axis calculation for %s" % scan.path)
         self._axis_params.frame_width = scan.dim_1
@@ -751,7 +753,7 @@ class AxisProcess(
                     dataset=scan, process=self, state=DatasetState.FAILED, details=info
                 )
             else:
-                info = "axis calculation defined for {}: {} (using {})" "".format(
+                info = "axis calculation defined for {}: {} (using {})".format(
                     str(scan.path),
                     str(scan.axis_params.relative_cor_value),
                     scan.axis_params.mode.value,
@@ -863,8 +865,7 @@ class AxisProcess(
             scan_name = scan.path or "undef scan"
             scan.axis_params.set_relative_value(None)
             raise Exception(
-                "Fail to compute axis position for {} reason is {}"
-                "".format(scan_name, e)
+                f"Fail to compute axis position for {scan_name} reason is {e}"
             )
         else:
             scan.axis_params.set_relative_value(position)
@@ -875,12 +876,9 @@ class AxisProcess(
                 method = "sinogram"
             else:
                 method = scan.axis_params.mode.value
+            r_cor_value = scan.axis_params.relative_cor_value
             mess = (
-                "Compute axis position ({value}) with {method} for {scan_name}".format(
-                    value=str(scan.axis_params.relative_cor_value),
-                    method=method,
-                    scan_name=scan_name,
-                )
+                f"Compute axis position ({r_cor_value}) with {method} for {scan_name}"
             )
             _logger.info(mess)
         if self._return_dict:

tomwer/core/process/reconstruction/axis/mode.py

@@ -28,9 +28,10 @@ __license__ = "MIT"
 __date__ = "15/10/2019"
 
 
-from silx.utils.enum import Enum as _Enum
 import logging
 
+from silx.utils.enum import Enum as _Enum
+
 _logger = logging.getLogger(__name__)
 
 

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

@@ -28,23 +28,25 @@ __license__ = "MIT"
 __date__ = "04/03/2019"
 
 
-from silx.utils.enum import Enum as _Enum
-
-from .anglemode import CorAngleMode
-from tomwer.core.utils import getParametersFromParOrInfo
-from .projectiontype import ProjectionType
-from .mode import AxisMode
-from collections import namedtuple
-from silx.io.url import DataUrl
-from tomoscan.esrf.scan.utils import get_data
 import logging
-import numpy
 import os
-import h5py
+from collections import namedtuple
 from typing import Union
+
+import h5py
+import numpy
+from silx.io.url import DataUrl
+from silx.utils.deprecation import deprecated
+from silx.utils.enum import Enum as _Enum
+from tomoscan.esrf.scan.utils import get_data
+
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
-from silx.utils.deprecation import deprecated
+from tomwer.core.utils import getParametersFromParOrInfo
+
+from .anglemode import CorAngleMode
+from .mode import AxisMode
+from .projectiontype import ProjectionType
 
 try:
     from nabu.preproc.phase import PaganinPhaseRetrieval
@@ -264,7 +266,7 @@ class AxisRP:
         """do image scaling"""
         self.__padding_mode = None
         self.__frame_width = None
-        self.__side = "all"
+        self.__side = "right"
         """side of the cor. Requested by nabu cor algorithms growing-window
         and sliding-window"""
         self.__flip_lr = True
@@ -293,8 +295,7 @@ class AxisRP:
                     name = AxisMode.global_.name
                 elif name == "accurate":
                     _logger.info(
-                        "convert axis mode {} to {} (renamed)"
-                        "".format(name, AxisMode.centered.name)
+                        f"convert axis mode {name} to {AxisMode.centered.name} (renamed)"
                     )
                     name = AxisMode.centered.name
                 elif name == "growing-window":
@@ -312,7 +313,7 @@ class AxisRP:
                 except Exception:
                     _mode = AxisMode.from_value(name)
             except Exception:
-                raise ValueError("Fail to create axis mode from %s" % mode)
+                raise ValueError(f"Fail to create axis mode from {mode}")
         else:
             if not isinstance(mode, AxisMode):
                 raise TypeError(f"mode is expected to be an instance of {AxisMode}")
@@ -328,7 +329,7 @@ class AxisRP:
     def frame_width(self, value):
         if not isinstance(value, (type(None), float, int)):
             raise TypeError(
-                "Value is expected to be None or a float. Not {}".format(type(value))
+                f"Value is expected to be None or a float. Not {type(value)}"
             )
         if value is None:
             self.__frame_width = value
@@ -410,7 +411,7 @@ class AxisRP:
     @side.setter
     def side(self, side):
         if side not in ("all", "left", "right", "center", "near"):
-            raise ValueError("side '{}' is not managed".format(side))
+            raise ValueError(f"side '{side}' is not managed")
         if self.__side != side:
             self.__side = side
             self.changed()
@@ -660,10 +661,7 @@ class AxisRP:
             ):
                 _dict = getParametersFromParOrInfo(file_path)
                 if self.AXIS_POSITION_PAR_KEY.lower() not in _dict:
-                    err = "fail to find `%s` in %s" % (
-                        self.AXIS_POSITION_PAR_KEY,
-                        file_path,
-                    )
+                    err = f"fail to find `{self.AXIS_POSITION_PAR_KEY}` in {file_path}"
                     _logger.info(err)
                     raise KeyError(err)
                 else:
@@ -725,8 +723,7 @@ class AxisRP:
         elif len(processes) > 1:
             _logger.info("found more than one value computed for " "center of rotation")
         _logger.info(
-            "load center of rotation from %s: %s"
-            % (file_path, processes[0].results["center_of_rotation"])
+            f"load center of rotation from {file_path}: {processes[0].results['center_of_rotation']}"
         )
         cor = processes[0].results["center_of_rotation"]
         if cor in [None, ""]:
@@ -862,16 +859,14 @@ class AxisRP:
         pass
 
     def get_simple_str(self):
-        results = "{}".format(self.mode.value)
+        results = f"{self.mode.value}"
         if self.mode in (
             AxisMode.growing_window_radios,
             AxisMode.growing_window_sinogram,
             AxisMode.sliding_window_radios,
             AxisMode.sliding_window_sinogram,
         ):
-            extra_info = "side: {}, use sinogram: {}".format(
-                self.side, self.use_sinogram
-            )
+            extra_info = f"side: {self.side}, use sinogram: {self.use_sinogram}"
             results = ", ".join((results, extra_info))
         return results
 

tomwer/core/process/reconstruction/darkref/darkrefs.py

@@ -30,27 +30,28 @@ __authors__ = ["C. Nemoz", "H.Payno"]
 __license__ = "MIT"
 __date__ = "06/09/2017"
 
+import logging
 import os
 import typing
-import logging
 from queue import Queue
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.io.url import DataUrl
+from silx.io.utils import h5py_read_dataset
+from tomoscan.framereducerbase import REDUCER_TARGET, ReduceMethod
+from tomoscan.io import HDF5File
+
 import tomwer.version
-from tomwer.utils import docstring
-from tomwer.core import settings
-from tomwer.core import utils
+from tomwer.core import settings, utils
 from tomwer.core.process.task import Task
-from tomwer.core.utils.scanutils import data_identifier_to_scan
-from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from . import params as dkrf_reconsparams
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomoscan.framereducerbase import ReduceMethod, REDUCER_TARGET
-from processview.core.manager import ProcessManager
-from tomoscan.io import HDF5File
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import DatasetState
-from silx.io.utils import h5py_read_dataset
-from silx.io.url import DataUrl
+from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.utils import docstring
+
+from . import params as dkrf_reconsparams
 
 logger = logging.getLogger(__name__)
 
@@ -247,7 +248,7 @@ class DarkRefs(
 
         with HDF5File(process_file, "r", swmr=True) as h5f:
             if entry not in h5f.keys():
-                logger.info("no dark found for {}".format(entry))
+                logger.info(f"no dark found for {entry}")
                 return {}
             dark_nodes = DarkRefs._get_process_nodes(
                 root_node=h5f[entry], process=DarkRefs
@@ -309,7 +310,7 @@ class DarkRefs(
 
         with HDF5File(process_file, "r", swmr=True) as h5f:
             if entry not in h5f.keys():
-                logger.info("no flats found for {}".format(entry))
+                logger.info(f"no flats found for {entry}")
                 return {}
             dkref_nodes = DarkRefs._get_process_nodes(
                 root_node=h5f[entry], process=DarkRefs
@@ -326,7 +327,7 @@ class DarkRefs(
             if (len(index_to_path)) > 1:
                 logger.debug(
                     "several processing found for dark-ref,"
-                    "take the last one: %s" % last_process_dkrf
+                    f"take the last one: {last_process_dkrf}"
                 )
 
             res = {}
@@ -378,7 +379,7 @@ class DarkRefs(
             process=self,
             state=DatasetState.ON_GOING,
         )
-        logger.processStarted("start dark and ref for {}" "".format(str(scan)))
+        logger.processStarted(f"start dark and ref for {scan}")
         if (
             settings.isOnLbsram(scan)
             and utils.isLowOnMemory(settings.get_lbsram_path()) is True
@@ -398,7 +399,7 @@ class DarkRefs(
             return
 
         if not (scan and os.path.exists(scan.path)):
-            mess = "folder {} is not existing".format(scan.path)
+            mess = f"folder {scan.folder} is not existing"
             logger.warning(mess)
             ProcessManager().notify_dataset_state(
                 dataset=scan, process=self, state=DatasetState.FAILED, details=mess
@@ -424,16 +425,11 @@ class DarkRefs(
             # if reduced already exists and user didn't asked for overwritting it
             if exists and not overwrite:
                 continue
-            logger.debug(
-                "compute {what} using mode {mode} for {scan}"
-                "".format(what=what, mode=mode, scan=str(scan))
-            )
+            logger.debug(f"compute {what} using mode {mode} for {scan}")
             try:
                 self.compute(scan=scan, target=what, method=mode, overwrite=True)
             except Exception as e:
-                info = "Fail computing dark and flat for {}. Reason is {}".format(
-                    str(scan), e
-                )
+                info = f"Fail computing dark and flat for {scan}. Reason is {e}"
                 self.notify_to_state_to_managed(
                     dataset=scan, state=DatasetState.FAILED, details=info
                 )
@@ -489,7 +485,7 @@ class DarkRefs(
                         process_index=scan.pop_process_index(),
                         overwrite=True,
                     )
-        logger.processSucceed("Dark and ref succeeded for {}" "".format(str(scan)))
+        logger.processSucceed(f"Dark and ref succeeded for {scan}")
         self.notify_to_state_to_managed(
             dataset=scan, state=DatasetState.SUCCEED, details=None
         )

tomwer/core/process/reconstruction/darkref/darkrefscopy.py

@@ -32,20 +32,24 @@ __license__ = "MIT"
 __date__ = "17/08/2021"
 
 
-import os
 import logging
+import os
 import tempfile
 from typing import Union
+
+from silx.io.dictdump import dicttoh5, h5todict
 from silx.io.url import DataUrl
-from silx.io.dictdump import dicttoh5
-from tomoscan.io import HDF5File
-from tomoscan.esrf.scan.utils import cwd_context
+from tomoscan.esrf.scan.utils import (
+    copy_h5_dict_darks_to,
+    copy_h5_dict_flats_to,
+    cwd_context,
+)
 from tomoscan.framereducerbase import REDUCER_TARGET
+from tomoscan.io import HDF5File
+
 from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-from tomoscan.esrf.scan.utils import copy_h5_dict_darks_to, copy_h5_dict_flats_to
-from silx.io.dictdump import h5todict
 
 logger = logging.getLogger(__name__)
 
@@ -92,9 +96,7 @@ class DarkRefsCopy(DarkRefs):
         if init_ref_scan:
             if not isinstance(init_ref_scan, TomwerScanBase):
                 raise TypeError(
-                    "init_ref_scan is expected to be an instance of TomwerScanBase. Not {}".format(
-                        type(init_ref_scan)
-                    )
+                    f"init_ref_scan is expected to be an instance of TomwerScanBase. Not {type(init_ref_scan)}"
                 )
             else:
                 self.set_darks_and_flats_from_scan(init_ref_scan)
@@ -216,9 +218,7 @@ class DarkRefsCopy(DarkRefs):
     def _copy_to(self, scan):
         if not isinstance(scan, TomwerScanBase):
             raise TypeError(
-                "{} is expected to be a {} and not {}".format(
-                    str(scan), TomwerScanBase, type(scan)
-                )
+                f"{scan} is expected to be an instance of {TomwerScanBase} and not {type(scan)}"
             )
 
         if self.has_dark_stored():
@@ -306,9 +306,7 @@ class DarkRefsCopy(DarkRefs):
         """Return True if the scan has already some dark processed"""
         if not isinstance(scan, TomwerScanBase):
             return TypeError(
-                "scan is expected to be an instance of {} and not {}".format(
-                    TomwerScanBase, type(scan)
-                )
+                f"scan is expected to be an instance of {TomwerScanBase} and not {type(scan)}"
             )
         else:
             return scan.reduced_darks or scan.load_reduced_darks()
@@ -317,9 +315,7 @@ class DarkRefsCopy(DarkRefs):
         """Return True if the scan has already some dark processed"""
         if not isinstance(scan, TomwerScanBase):
             return TypeError(
-                "scan is expected to be an instance of {} and not {}".format(
-                    TomwerScanBase, type(scan)
-                )
+                f"scan is expected to be an instance of {TomwerScanBase} and not {type(scan)}"
             )
         else:
             return scan.reduced_flats or scan.load_reduced_flats()

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

@@ -29,14 +29,16 @@ __date__ = "07/03/2019"
 
 
 import enum
+
 from silx.utils.enum import Enum as _Enum
+from tomoscan.framereducerbase import ReduceMethod
+
 from tomwer.core.process.reconstruction.darkref.settings import (
     DARKHST_PREFIX,
     REFHST_PREFIX,
 )
 from tomwer.core.process.reconstruction.paramsbase import _ReconsParam
 from tomwer.core.utils.deprecation import deprecated
-from tomoscan.framereducerbase import ReduceMethod
 
 
 # TODO: those classes (when, method) should be linked / embedded in the DarkRef

tomwer/core/process/reconstruction/lamino/tofu.py

@@ -28,27 +28,27 @@ __license__ = "MIT"
 __date__ = "01/06/2018"
 
 
+import enum
 import glob
+import logging
 import os
+import shutil
 import subprocess
 import sys
-import enum
-from collections import OrderedDict
 import tempfile
-import shutil
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.process.task import Task
+from collections import OrderedDict
+
+import tomwer.version
 from tomwer.core.process.reconstruction.darkref.settings import (
     DARKHST_PREFIX,
     REFHST_PREFIX,
 )
-from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.process.task import Task
+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 getDim1Dim2
 from tomwer.core.utils.char import PSI_CHAR
-import tomwer.version
-
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -417,10 +417,7 @@ def _preprocess_stitching(
         return True
 
     def stitching(shift, blend, adjust_mean):
-        work = "[read path=%s, read path=%s ! flip direction=horizontal]" % (
-            fc1_folder,
-            fc2_folder,
-        )
+        work = f"[read path={fc1_folder}, read path={fc2_folder} ! flip direction=horizontal]"
         work = work + " ! stitch shift=%s " % shift
         work += "blend=%s " % str(int(blend))
         work += "adjust-mean=%s " % str(int(adjust_mean))
@@ -767,8 +764,7 @@ class LaminoReconstruction(Task, input_names=("data",), output_names=("data",)):
             _scan = scan
         if not isinstance(_scan, TomwerScanBase):
             raise TypeError(
-                "input data is expected to be dict, str or "
-                "TomwerScanBase not {}".format(type(_scan))
+                f"input data is expected to be dict, str or {TomwerScanBase} not {type(_scan)}"
             )
 
         # if need some preprocessing

tomwer/core/process/reconstruction/nabu/castvolume.py

@@ -31,31 +31,28 @@ __license__ = "MIT"
 __date__ = "15/12/2021"
 
 
+import logging
 import os
+
+import numpy
+from nabu.io.cast_volume import RESCALE_MAX_PERCENTILE, RESCALE_MIN_PERCENTILE
+from nabu.io.cast_volume import cast_volume as _nabu_cast_volume
+from nabu.io.cast_volume import get_default_output_volume
+from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
+from sluurp.executor import submit as submit_to_slurm_cluster
+from sluurp.job import SBatchScriptJob
+from tomoscan.volumebase import VolumeBase
+
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
+from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.process.reconstruction.nabu import settings
+from tomwer.core.process.reconstruction.nabu.nabucommon import NabuOutputFileFormat
 from tomwer.core.process.task import Task
-from tomwer.core.process.reconstruction.nabu.nabucommon import (
-    NabuOutputFileFormat,
-)
-from processview.core.manager import ProcessManager, DatasetState
-import numpy
-import logging
-from tomoscan.volumebase import VolumeBase
-from nabu.io.cast_volume import (
-    cast_volume as _nabu_cast_volume,
-    RESCALE_MIN_PERCENTILE,
-    RESCALE_MAX_PERCENTILE,
-    get_default_output_volume,
-)
-from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.slurm import get_slurm_script_name
-from tomwer.core.volume.volumefactory import VolumeFactory
-from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.utils.volumeutils import volume_identifier_to_volume
-from sluurp.job import SBatchScriptJob
-from sluurp.executor import submit as submit_to_slurm_cluster
+from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.volume.volumefactory import VolumeFactory
 
 _logger = logging.getLogger(__name__)
 

tomwer/core/process/reconstruction/nabu/nabucommon.py

@@ -32,37 +32,36 @@ __license__ = "MIT"
 __date__ = "27/10/2021"
 
 
-from tomwer.core.cluster.cluster import (
-    SlurmClusterConfiguration,
-)
+import logging
+import os
+import subprocess
+import uuid
+from typing import Iterable, Optional, Union
+
+import numpy
+from silx.io.url import DataUrl
+from silx.utils.enum import Enum as _Enum
 from sluurp.executor import submit as submit_to_slurm_cluster
 from sluurp.job import SBatchScriptJob
+from tomoscan.io import HDF5File
+from tomoscan.normalization import Method as INormMethod
+
+from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.process.reconstruction.nabu.target import Target
 from tomwer.core.process.reconstruction.nabu.utils import (
     _NabuPhaseMethod,
     nabu_std_err_has_error,
 )
-from tomwer.core.utils.scanutils import format_output_location
+from tomwer.core.process.reconstruction.normalization.params import (
+    _ValueSource as INormSource,
+)
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import format_output_location
 from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
-from tomwer.core.process.reconstruction.normalization.params import (
-    _ValueSource as INormSource,
-)
-from tomoscan.normalization import Method as INormMethod
-from silx.utils.enum import Enum as _Enum
-from silx.io.url import DataUrl
-from typing import Iterable, Optional
-from typing import Union
-import logging
-import subprocess
-from . import settings
-from . import utils
-import os
-import uuid
-from tomoscan.io import HDF5File
-import numpy
+
+from . import settings, utils
 
 _logger = logging.getLogger(__name__)
 try: