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

tomwer/core/process/test/test_lamino.py

@@ -31,9 +31,11 @@ __date__ = "05/04/2019"
 import shutil
 import tempfile
 import unittest
+
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF
+
 from ..reconstruction.lamino import LaminoReconstruction
-from tomwer.core.scan.scanbase import TomwerScanBase
 
 
 class TestLaminoIO(unittest.TestCase):

tomwer/core/process/test/test_nabu.py

@@ -30,17 +30,18 @@ __date__ = "14/02/2020"
 import os
 import shutil
 import tempfile
-from glob import glob
 import unittest
-from tomwer.tests.utils import UtilsTest
+from glob import glob
+
+from tomwer.core.process.reconstruction.axis import AxisRP
 from tomwer.core.process.reconstruction.nabu import nabuslices as nabu
+from tomwer.core.process.reconstruction.nabu import settings as nabu_settings
 from tomwer.core.process.reconstruction.nabu import utils as nabuutils
-from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.process.reconstruction.nabu.nabuslices import NabuSliceMode
-from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.process.reconstruction.axis import AxisRP
-from tomwer.core.process.reconstruction.nabu import settings as nabu_settings
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import MockEDF
+from tomwer.tests.utils import UtilsTest
 
 
 class TestNabuDescUtils(unittest.TestCase):
@@ -300,9 +301,9 @@ class TestTomwerConfForNabu(unittest.TestCase):
 
     def testSlices(self):
         # check if single value
-        for slice in ("1", NabuSliceMode.MIDDLE):
-            with self.subTest(slice=slice):
-                self.conf["tomwer_slices"] = slice
+        for data_slice in ("1", NabuSliceMode.MIDDLE):
+            with self.subTest(data_slice=data_slice):
+                self.conf["tomwer_slices"] = data_slice
 
                 sub_confs = nabu.interpret_tomwer_configuration(
                     self.conf, scan=self.scan
@@ -312,9 +313,9 @@ class TestTomwerConfForNabu(unittest.TestCase):
                 self.assertEqual(len(sub_confs), 1 + 1)
 
         # check single values or list of values
-        for slice in ("[2, 3, 7]", "(6, 9,56)", "5;6; 9"):
-            with self.subTest(slice=slice):
-                self.conf["tomwer_slices"] = slice
+        for data_slice in ("[2, 3, 7]", "(6, 9,56)", "5;6; 9"):
+            with self.subTest(slice=data_slice):
+                self.conf["tomwer_slices"] = data_slice
 
                 sub_confs = nabu.interpret_tomwer_configuration(
                     self.conf, scan=self.scan

tomwer/core/process/test/test_normalization.py

@@ -27,14 +27,16 @@ __license__ = "MIT"
 __date__ = "11/07/2021"
 
 
-from tomwer.core.process.reconstruction.normalization import params, normalization
-from tomoscan.normalization import Method
-from tomwer.core.utils.scanutils import MockHDF5
-import unittest
-import tempfile
 import shutil
+import tempfile
+import unittest
+
 import h5py
 import numpy
+from tomoscan.normalization import Method
+
+from tomwer.core.process.reconstruction.normalization import normalization, params
+from tomwer.core.utils.scanutils import MockHDF5
 
 
 class TestNormalization(unittest.TestCase):

tomwer/core/process/test/test_timer.py

@@ -31,9 +31,10 @@ __date__ = "05/04/2019"
 import shutil
 import tempfile
 import unittest
-from tomwer.core.utils.scanutils import MockEDF
+
 from tomwer.core.process.control.timer import Timer
 from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF
 
 
 class TestTimerIO(unittest.TestCase):

tomwer/core/process/utils.py

@@ -28,16 +28,18 @@ __license__ = "MIT"
 __date__ = "04/03/2019"
 
 
-from collections import OrderedDict
 import datetime
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.blissscan import BlissScan
+import logging
+import typing
+from collections import OrderedDict
+
+import h5py
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
+
 from tomwer.core.process.reconstruction.scores import ComputedScore
-import h5py
-import typing
-import logging
+from tomwer.core.scan.blissscan import BlissScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
@@ -106,9 +108,7 @@ def get_scores(node: h5py.Group) -> typing.Union[None, dict]:
                 )
                 scores[float(res_item)] = (url, score)
             except Exception as e:
-                _logger.warning(
-                    "Unable to load {}. Reason is {}".format(score_node.name, str(e))
-                )
+                _logger.warning(f"Unable to load {score_node.name}. Reason is {e}")
         scores = dict(sorted(scores.items(), key=lambda item: item[0]))
 
         return scores

tomwer/core/progress.py

@@ -29,9 +29,9 @@ __license__ = "MIT"
 __date__ = "07/08/2019"
 
 
+import logging
 import sys
 from enum import Enum
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -82,9 +82,8 @@ class Progress(object):
     def setAdvancement(self, value):
         length = 20  # modify this to change the length
         block = int(round(length * value / 100))
-        msg = "\r{0}: [{1}] {2}%".format(
-            self._name, "#" * block + "-" * (length - block), round(value, 2)
-        )
+        blocks_str = "#" * block + "-" * (length - block)
+        msg = f"\r{self._name}: [{blocks_str}] {round(value, 2)}%"
         if value >= 100:
             msg += " DONE\r\n"
         sys.stdout.write(msg)

tomwer/core/scan/blissscan.py

@@ -29,6 +29,7 @@ __date__ = "09/08/2018"
 
 
 import os
+
 import h5py
 
 try:
@@ -48,11 +49,12 @@ except ImportError:
     from nxtomomill.settings import H5_INIT_TITLES
     from nxtomomill.settings import H5_ZSERIE_INIT_TITLES
     from nxtomomill.settings import H5_PCOTOMO_INIT_TITLES
-from silx.io.utils import h5py_read_dataset
+
 import logging
-from tomoscan.io import HDF5File
 from typing import Optional
 
+from silx.io.utils import h5py_read_dataset
+from tomoscan.io import HDF5File
 
 _logger = logging.getLogger(__name__)
 

tomwer/core/scan/edfscan.py

@@ -28,31 +28,34 @@ __license__ = "MIT"
 __date__ = "09/08/2018"
 
 
+import functools
+import logging
 import os
 import re
 from collections import OrderedDict
+from glob import glob
 from math import ceil
+from typing import Optional
+
 import fabio
 import numpy
-import functools
-import logging
+from processview.core.dataset import DatasetIdentifier
+from silx.io.url import DataUrl
+from tomoscan.esrf.identifier.edfidentifier import (
+    EDFTomoScanIdentifier as _EDFTomoScanIdentifier,
+)
+from tomoscan.esrf.scan.edfscan import EDFTomoScan as _tsEDFTomoScan
+from tomoscan.esrf.scan.utils import get_data
 from tomoscan.scanbase import FOV
+
 from tomwer.core.process.reconstruction.darkref.settings import (
-    REFHST_PREFIX,
     DARKHST_PREFIX,
+    REFHST_PREFIX,
 )
 from tomwer.core.progress import Progress
-from silx.io.url import DataUrl
-from tomoscan.esrf.scan.utils import get_data
-from glob import glob
-from .scanbase import TomwerScanBase
-from tomoscan.esrf.scan.edfscan import EDFTomoScan as _tsEDFTomoScan
-from tomoscan.esrf.identifier.edfidentifier import (
-    EDFTomoScanIdentifier as _EDFTomoScanIdentifier,
-)
 from tomwer.utils import docstring
-from processview.core.dataset import DatasetIdentifier
-from typing import Optional
+
+from .scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
@@ -223,8 +226,8 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             return a dict with the index of the slice reconstructed.
         """
 
-        def containsDigits(input):
-            return any(char.isdigit() for char in input)
+        def containsDigits(input_):
+            return any(char.isdigit() for char in input_)
 
         if (scanID is None) or (not os.path.isdir(scanID)):
             if withIndex is True:
@@ -308,8 +311,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
         :rtype: numpy.array
         """
         _logger.info(
-            "compute sinogram for line %s of %s (subsampling: %s)"
-            % (line, self.path, subsampling)
+            f"compute sinogram for line {line} of {self.path} (subsampling: {subsampling})"
         )
         assert isinstance(line, int)
         if self.tomo_n is not None and self.dim_2 is not None and line > self.dim_2:
@@ -323,8 +325,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             proj_sort = list(filter(lambda x: not isinstance(x, str), proj_sort))
             proj_sort.sort()
             advancement = Progress(
-                name="compute sinogram for %s, line=%s,"
-                "sampling=%s" % (os.path.basename(self.path), line, subsampling)
+                name=f"compute sinogram for {os.path.basename(self.path)}, line={line}, sampling={subsampling}"
             )
             advancement.setMaxAdvancement(len(proj_sort))
             for i_proj, proj in enumerate(proj_sort):
@@ -393,7 +394,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             return None
         path = os.path.join(self.path, f)
         if os.path.exists(path):
-            _logger.info("Getting %s from %s" % (what, f))
+            _logger.info(f"Getting {what} from {f}")
             try:
                 data = fabio.open(path).data
             except Exception:
@@ -456,8 +457,7 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
 
             if len(oProj) > 2:
                 _logger.info(
-                    "Only bordering projections (%s and %s) will "
-                    "be used for extracting %s" % (lowPI, uppPI, what)
+                    f"Only bordering projections ({lowPI} and {uppPI}) will be used for extracting {what}"
                 )
 
             uppPI = uppPI
@@ -468,15 +468,13 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             if (index >= lowPI) is False:
                 index = lowPI
                 _logger.warning(
-                    "ProjectionI not in the files indexes"
-                    "range (projectionI >= lowerProjIndex)"
+                    "ProjectionI not in the files indexes range (projectionI >= lowerProjIndex)"
                 )
 
             if (index <= uppPI) is False:
                 index = uppPI
                 _logger.warning(
-                    "ProjectionI not in the files indexes"
-                    "range upperProjIndex >= projectionI"
+                    "ProjectionI not in the files indexes range upperProjIndex >= projectionI"
                 )
 
             # simple interpolation
@@ -524,9 +522,8 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
     def _deduce_transfert_scan(self, output_dir):
         if os.path.basename(output_dir) != os.path.basename(self.path):
             raise ValueError(
-                "Transfert to a new EDFTomoScan requires an "
-                "equal basename. Current path is {}, requested "
-                "one is {}".format(self.path, output_dir)
+                "Transfert to a new EDFTomoScan requires an equal basename. "
+                f"Current path is {self.path}, requested one is {output_dir}"
             )
         # here: avoir reloading the metadata because not sure there will be some processing after the 'data transfert'. And can be long with EDF + GPFS at esrf
         return EDFTomoScan(scan=output_dir, update=False)

tomwer/core/scan/futurescan.py

@@ -1,6 +1,7 @@
-from tomwer.core.futureobject import TomwerScanBase
 from silx.utils.deprecation import deprecated
 
+from tomwer.core.futureobject import TomwerScanBase
+
 
 @deprecated(replacement="TomwerScanBase", since_version="1.0")
 class FutureTomwerScan(TomwerScanBase):

tomwer/core/scan/hdf5scan.py

@@ -28,35 +28,34 @@ __license__ = "MIT"
 __date__ = "09/08/2018"
 
 
-from .scanbase import TomwerScanBase
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _tsHDF5TomoScan
-from tomoscan.esrf.identifier.hdf5Identifier import (
-    HDF5TomoScanIdentifier as _HDF5TomoScanIdentifier,
-)
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.io import HDF5File
-from processview.core.dataset import DatasetIdentifier
 import functools
-import json
 import io
-import h5py
-import os
-from tomwer.utils import docstring
+import json
 import logging
+import os
 from typing import Optional
 from urllib.parse import urlparse
-from tomoscan.esrf.identifier.url_utils import (
-    UrlSettings,
-    split_path,
-    split_query,
+
+import h5py
+from processview.core.dataset import DatasetIdentifier
+from tomoscan.esrf.identifier.hdf5Identifier import (
+    HDF5TomoScanIdentifier as _HDF5TomoScanIdentifier,
 )
+from tomoscan.esrf.identifier.url_utils import UrlSettings, split_path, split_query
+from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _tsHDF5TomoScan
+from tomoscan.esrf.scan.hdf5scan import ImageKey
+from tomoscan.io import HDF5File
+
+from tomwer.utils import docstring
+
+from .scanbase import TomwerScanBase
 
 _logger = logging.getLogger(__name__)
 
 
 class HDF5TomoScanIdentifier(_HDF5TomoScanIdentifier, DatasetIdentifier):
-    def __init__(self, object, hdf5_file, entry):
-        super().__init__(object, hdf5_file, entry)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         DatasetIdentifier.__init__(self, data_builder=HDF5TomoScan.from_identifier)
 
     @staticmethod
@@ -325,9 +324,7 @@ class HDF5TomoScan(_tsHDF5TomoScan, TomwerScanBase):
             for frame in frames:
                 if frame.image_key is ImageKey.PROJECTION:
                     if frame.is_control:
-                        self._cache_proj_urls[
-                            "{} (1)".format(frame.rotation_angle)
-                        ] = frame.url
+                        self._cache_proj_urls[f"{frame.rotation_angle} (1)"] = frame.url
                     else:
                         self._cache_proj_urls[str(frame.rotation_angle)] = frame.url
         return self._cache_proj_urls
@@ -460,16 +457,12 @@ class HDF5TomoScan(_tsHDF5TomoScan, TomwerScanBase):
     @docstring(TomwerScanBase)
     def get_nabu_dataset_info(self, binning=1, binning_z=1, proj_subsampling=1):
         if not isinstance(binning, int):
-            raise TypeError("binning should be an int. Not {}".format(type(binning)))
+            raise TypeError(f"binning should be an int. Not {type(binning)}")
         if not isinstance(binning_z, int):
-            raise TypeError(
-                "binning_z should be an int. Not {}".format(type(binning_z))
-            )
+            raise TypeError(f"binning_z should be an int. Not {type(binning_z)}")
         if not isinstance(proj_subsampling, int):
             raise TypeError(
-                "proj_subsampling should be an int. Not {}".format(
-                    type(proj_subsampling)
-                )
+                f"proj_subsampling should be an int. Not {type(proj_subsampling)}"
             )
         return {
             "hdf5_entry": self.entry,

tomwer/core/scan/scanbase.py

@@ -28,29 +28,30 @@ __license__ = "MIT"
 __date__ = "09/08/2018"
 
 
-import numpy
-import logging
-import typing
-import json
 import io
+import json
+import logging
 import os
+import typing
 from glob import glob
+from typing import Optional
+
+import numpy
 from silx.io.url import DataUrl
-from tomwer.core.tomwer_object import TomwerObject
-from tomwer.core.utils.locker import FileLockerManager, FileLockerContext
-from tomwer.core.utils.ftseriesutils import orderFileByLastLastModification
-from tomoscan.normalization import IntensityNormalization
-from tomoscan.io import HDF5File
+from silx.utils.enum import Enum as _Enum
 from tomoscan.identifier import VolumeIdentifier
+from tomoscan.io import HDF5File
+from tomoscan.normalization import IntensityNormalization
 from tomoscan.volumebase import VolumeBase
-from typing import Optional
-from silx.utils.enum import Enum as _Enum
-from tomwer.core.volume.hdf5volume import HDF5Volume
+
+from tomwer.core.tomwer_object import TomwerObject
+from tomwer.core.utils.ftseriesutils import orderFileByLastLastModification
+from tomwer.core.utils.locker import FileLockerContext, FileLockerManager
 from tomwer.core.volume.edfvolume import EDFVolume
+from tomwer.core.volume.hdf5volume import HDF5Volume
 from tomwer.core.volume.jp2kvolume import JP2KVolume
 from tomwer.core.volume.tiffvolume import MultiTIFFVolume
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -327,10 +328,10 @@ class TomwerScanBase(TomwerObject):
             del self._cache_radio_axis[(mode, nearest)]
 
         def compute():
+            from ..process.reconstruction.axis.anglemode import CorAngleMode
             from ..process.reconstruction.axis.params import (
                 AxisResource,
             )  # avoid cyclic import
-            from ..process.reconstruction.axis.anglemode import CorAngleMode
 
             _mode = CorAngleMode.from_value(mode)
             if self.path is None:  # pylint: disable=E1101
@@ -759,8 +760,7 @@ class TomwerScanBase(TomwerObject):
                     if len(indexes) > 0:
                         self._process_index = max(indexes) + 1
                         logger.debug(
-                            "set process_index from tomwer process file"
-                            "to {}".format(self._process_index)
+                            f"set process_index from tomwer process file to {self._process_index}"
                         )
 
     def get_nabu_dataset_info(self, binning=1, binning_z=1, proj_subsampling=1):
@@ -790,8 +790,8 @@ class _TomwerBaseDock(object):
         return self.__instance
 
 
-def _containsDigits(input):
-    return any(char.isdigit() for char in input)
+def _containsDigits(input_):
+    return any(char.isdigit() for char in input_)
 
 
 def _get_reconstructed_single_file_volume(

tomwer/core/scan/scanfactory.py

@@ -28,22 +28,25 @@ __license__ = "MIT"
 __date__ = "27/02/2019"
 
 
+import glob
+import logging
+import os
+from typing import Union
+from urllib.parse import urlparse
+
 import h5py
-from tomoscan.scanbase import TomoScanBase
-from tomoscan.factory import Factory as _oScanFactory
+from tomoscan.esrf.identifier.url_utils import split_path
 from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _oHDF5TomoScan
+from tomoscan.factory import Factory as _oScanFactory
 from tomoscan.identifier import BaseIdentifier, ScanIdentifier, VolumeIdentifier
+from tomoscan.scanbase import TomoScanBase
 from tomoscan.tomoobject import TomoObject
+
 from tomwer.utils import docstring
-from typing import Union
+
+from .blissscan import BlissScan
 from .edfscan import EDFTomoScan, EDFTomoScanIdentifier
 from .hdf5scan import HDF5TomoScan, HDF5TomoScanIdentifier
-from .blissscan import BlissScan
-import os
-import glob
-import logging
-from urllib.parse import urlparse
-from tomoscan.esrf.identifier.url_utils import split_path
 
 _logger = logging.getLogger(__name__)
 
@@ -140,9 +143,8 @@ class ScanFactory(object):
                 entry = valid_entries[-1]
             elif entry not in valid_entries:
                 raise ValueError(
-                    "entry {} is invalid. Does it exists ? Is the "
-                    "file NXTomo compliant ?. Valid entry are {}"
-                    "".format(entry, valid_entries)
+                    f"entry {entry} is invalid. Does it exists ? Is the "
+                    f"file NXTomo compliant ?. Valid entry are {valid_entries}"
                 )
             return HDF5TomoScan(scan=scan_path, entry=entry)
         elif ScanFactory.is_edf_tomo(scan_path):
@@ -152,13 +154,12 @@ class ScanFactory(object):
                 valid_entries = BlissScan.get_valid_entries(scan_path)
                 if len(valid_entries) > 1:
                     _logger.warning(
-                        "more than one entry found for %s."
-                        "Pick the last entry" % scan_path
+                        f"more than one entry found for {scan_path}. Pick the last entry"
                     )
                 entry = valid_entries[-1]
             return BlissScan(master_file=scan_path, entry=entry, proposal_file=None)
 
-        raise ValueError("Unable to generate a scan object from %s" % scan_path)
+        raise ValueError(f"Unable to generate a scan object from {scan_path}")
 
     @docstring(_oScanFactory.create_scan_objects)
     @staticmethod
@@ -183,9 +184,9 @@ class ScanFactory(object):
         return tuple()
 
     @staticmethod
-    def mock_scan(type="edf"):
+    def mock_scan(type_="edf"):
         """Mock a scan structure which is not associated to any real acquistion"""
-        if type == "edf":
+        if type_ == "edf":
             return EDFTomoScan(scan=None)
         else:
             raise NotImplementedError("Other TomoScan are not defined yet")
@@ -194,9 +195,7 @@ class ScanFactory(object):
     def create_scan_object_frm_dict(_dict):
         if TomoScanBase.DICT_TYPE_KEY not in _dict:
             raise ValueError(
-                "given dict is not recognized. Cannot find {}".format(
-                    TomoScanBase.DICT_TYPE_KEY
-                )
+                f"given dict is not recognized. Cannot find {TomoScanBase.DICT_TYPE_KEY}"
             )
         elif _dict[TomoScanBase.DICT_TYPE_KEY] == EDFTomoScan._TYPE:
             return EDFTomoScan(scan=None).load_from_dict(_dict)
@@ -204,7 +203,7 @@ class ScanFactory(object):
             return HDF5TomoScan.from_dict(_dict)
         else:
             raise ValueError(
-                "Scan type {} is not managed".format(_dict[TomoScanBase.DICT_TYPE_KEY])
+                f"Scan type {_dict[TomoScanBase.DICT_TYPE_KEY]} is not managed"
             )
 
     @staticmethod

tomwer/core/scan/scantype.py

@@ -0,0 +1,7 @@
+from silx.utils.enum import Enum as _Enum
+
+
+class ScanType(_Enum):
+    BLISS = "bliss-hdf5"
+    SPEC = "spec-edf"
+    NX_TOMO = "NXtomo"

tomwer/core/scan/test/test_edf.py

@@ -29,9 +29,10 @@ __license__ = "MIT"
 __date__ = "23/11/2021"
 
 
+import os
+
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.utils.scanutils import MockEDF
-import os
 
 
 def test_scan_dir(tmpdir):

tomwer/core/scan/test/test_future_scan.py

@@ -30,9 +30,10 @@ __date__ = "04/11/2021"
 
 
 import asyncio
+import os
+
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.scanutils import MockHDF5
-import os
 
 
 def test_simple_future_tomo_obj(tmpdir):

tomwer/core/scan/test/test_h5.py

@@ -28,14 +28,15 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "16/09/2019"
 
-import unittest
-import shutil
 import os
+import shutil
 import tempfile
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+import unittest
+
 from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.tests.utils import UtilsTest
 
 
 class TestHDF5Scan(unittest.TestCase):

tomwer/core/scan/test/test_process_registration.py

@@ -28,12 +28,14 @@ __license__ = "MIT"
 __date__ = "02/09/2020"
 
 
+import shutil
+import tempfile
 import unittest
+
+from tomoscan.io import HDF5File
+
 from tomwer.core.process.task import Task
 from tomwer.core.utils.scanutils import MockHDF5
-import tempfile
-import shutil
-from tomoscan.io import HDF5File
 
 
 class TestProcessRegistration(unittest.TestCase):