tomwer 1.4.18__py3-none-any.whl → 1.5.0__py3-none-any.whl

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

@@ -129,6 +129,7 @@ class CastVolumeTask(
 
         # build output volume object
         overwrite = configuration.get("overwrite", False)
+        remove_input_volume = configuration.get("remove_input_volume", False)
         output_volume.overwrite = overwrite
         cratios = configuration.get("compression_ratios", None)
         if cratios is not None:
@@ -161,6 +162,7 @@ class CastVolumeTask(
                     rescale_max_percentile=rescale_max_percentile,
                     save=True,
                     store=False,
+                    remove_input_volume=remove_input_volume,
                 )
             except Exception as e:
                 mess = f"volume cast of {str(input_volume)} failed. Reason is {str(e)}"
@@ -203,7 +205,8 @@ class CastVolumeTask(
                     command += f" --rescale_min_percentile={rescale_min_percentile}"
                 if rescale_max_percentile is not None:
                     command += f" --rescale_max_percentile={rescale_max_percentile}"
-
+                if remove_input_volume:
+                    command += " --remove-input-volume"
                 return command
 
             script_name = get_slurm_script_name(prefix="nabu_cast")

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

@@ -34,7 +34,9 @@ class NabuHelicalPrepareWeightsDouble(
             scan.master_file,
             extra_options={"h5_entry": scan.entry},
         )
-        update_dataset_info_flats_darks(dataset_info, flatfield_mode=1)
+        update_dataset_info_flats_darks(
+            dataset_info, flatfield_mode=1, loading_mode="load_if_present"
+        )
 
         mappe = 0
         my_flats = load_images_from_dataurl_dict(dataset_info.flats)

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

@@ -205,7 +205,7 @@ class _NabuBaseReconstructor:
         axis: NabuPlane = NabuPlane.XY,
     ) -> None:
         self._scan = scan
-        self._target = Target.from_value(target)
+        self._target = Target(target)
         self._dry_run = dry_run
         self._process_name = process_name
         self._process = None
@@ -564,7 +564,7 @@ class _NabuBaseReconstructor:
         )
 
         source = extra_infos.get("source", INormSource.NONE)
-        source = INormSource.from_value(source)
+        source = INormSource(source)
 
         if source is INormSource.NONE:
             pass

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

@@ -390,7 +390,7 @@ class _Reconstructor(_NabuBaseReconstructor):
             _config["reconstruction"]["end_z"] = self.slice_index
         else:
             raise ValueError(
-                f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                f"self.axis has an invalid value: {self.axis} when expected to be in {[item.value for item in NabuPlane]}"
             )
         return _config, file_prefix
 

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

@@ -54,7 +54,7 @@ from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
 from processview.core.superviseprocess import SuperviseProcess
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -612,7 +612,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 config["reconstruction"]["end_z"] = self.slice_index
             else:
                 raise ValueError(
-                    f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                    f"self.axis has an invalid value: {self.axis} when expected to be in {[item.value for item in NabuPlane]}"
                 )
 
         if self.slice_index is not None:
@@ -842,7 +842,7 @@ class NabuSliceMode(_Enum):
     def getSlices(slices, scan, axis=NabuPlane.XY) -> tuple:
         res = []
         try:
-            mode = NabuSliceMode.from_value(slices)
+            mode = NabuSliceMode(slices)
         except ValueError:
             try:
                 res = utils.retrieve_lst_of_value_from_str(slices, type_=int)
@@ -850,7 +850,7 @@ class NabuSliceMode(_Enum):
                 pass
         else:
             if mode == mode.MIDDLE:
-                axis = NabuPlane.from_value(axis)
+                axis = NabuPlane(axis)
                 if axis is NabuPlane.XY:
                     n_slice = scan.dim_2 or 2048
                 elif axis in (NabuPlane.YZ, NabuPlane.XZ):

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

@@ -1,6 +1,6 @@
 """Define nabu Axis"""
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class NabuPlane(_Enum):
@@ -16,4 +16,4 @@ class NabuPlane(_Enum):
             return NabuPlane.XZ
         elif value == 2:
             return NabuPlane.YZ
-        return super().from_value(value=value)
+        return NabuPlane(value=value)

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

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class Target(_Enum):

tomwer/core/process/reconstruction/nabu/test/test_castvolume.py

@@ -107,6 +107,7 @@ def test_cast_volume_32bitstiff_to_16bits_tiff(tmp_path):
                 "output_dir": str(save_dir),
                 "output_file_format": NabuOutputFileFormat.HDF5,
                 "output_data_type": numpy.int16,
+                "remove_input_volume": True,
             },
             "output_volume": output_volume.get_identifier().to_str(),
         },
@@ -114,3 +115,4 @@ def test_cast_volume_32bitstiff_to_16bits_tiff(tmp_path):
     task.run()
     assert task.outputs.volume.load_data().shape == (20, 100, 100)
     assert task.outputs.volume.load_data().dtype == numpy.int16
+    assert not os.path.exists(volume.data_url.file_path())

tomwer/core/process/reconstruction/nabu/test/test_nabu_utils.py

@@ -275,3 +275,12 @@ def test_nabu_std_err_has_error():
         )
         is False
     )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""Performing MLEM-WL2 iterations: 0%|     | 0/200[00:00<?, ?its/s]
+            Performing MLEM-WL2 iterations: 82%|     | 163/200[00:00<?, 828.12its/s]
+            """
+        )
+        is False
+    )

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

@@ -10,7 +10,7 @@ from nabu.pipeline.config import generate_nabu_configfile, parse_nabu_config_fil
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 
 from tomoscan.identifier import VolumeIdentifier
 import tomwer.version
@@ -240,13 +240,13 @@ def get_multi_cor_recons_volume_identifiers(
     return res
 
 
-class _NabuMode(_Enum):
+class _NabuMode(Enum):
     FULL_FIELD = "standard acquisition"
     HALF_ACQ = "half acquisition"
     # HELICAL = "helical acquisition"
 
 
-class _NabuStages(_Enum):
+class _NabuStages(Enum):
     INI = "initialization"
     PRE = "pre-processing"
     PHASE = "phase"
@@ -267,7 +267,7 @@ class _NabuStages(_Enum):
     @staticmethod
     def getProcessEnum(stage):
         """Return the process Enum associated to the stage"""
-        stage = _NabuStages.from_value(stage)
+        stage = _NabuStages(stage)
         if stage is _NabuStages.INI:
             raise NotImplementedError()
         elif stage is _NabuStages.PRE:
@@ -281,7 +281,7 @@ class _NabuStages(_Enum):
         raise NotImplementedError()
 
 
-class _NabuPreprocessing(_Enum):
+class _NabuPreprocessing(Enum):
     """Define all the preprocessing action possible and the order they
     are applied on"""
 
@@ -296,7 +296,7 @@ class _NabuPreprocessing(_Enum):
         )
 
 
-class _NabuPhase(_Enum):
+class _NabuPhase(Enum):
     """Define all the phase action possible and the order they
     are applied on"""
 
@@ -309,7 +309,7 @@ class _NabuPhase(_Enum):
         return (_NabuPhase.PHASE, _NabuPhase.UNSHARP_MASK, _NabuPhase.LOGARITHM)
 
 
-class _NabuProcessing(_Enum):
+class _NabuProcessing(Enum):
     """Define all the processing action possible"""
 
     RECONSTRUCTION = "reconstruction"
@@ -319,7 +319,7 @@ class _NabuProcessing(_Enum):
         return (_NabuProcessing.RECONSTRUCTION,)
 
 
-class _NabuPostProcessing(_Enum):
+class _NabuPostProcessing(Enum):
     """Define all the post processing action available"""
 
     SAVE_DATA = "save"
@@ -329,11 +329,12 @@ class _NabuPostProcessing(_Enum):
         return (_NabuPostProcessing.SAVE_DATA,)
 
 
-class _NabuReconstructionMethods(_Enum):
+class _NabuReconstructionMethods(Enum):
     FBP = "FBP"
+    MLEM = "MLEM"
 
 
-class _NabuPhaseMethod(_Enum):
+class _NabuPhaseMethod(Enum):
     """
     Nabu phase method
     """
@@ -354,10 +355,10 @@ class _NabuPhaseMethod(_Enum):
             elif value.lower() == "ctf":
                 return _NabuPhaseMethod.CTF
         else:
-            return super().from_value(value=value)
+            return _NabuPhaseMethod(value=value)
 
 
-class _NabuFBPFilterType(_Enum):
+class _NabuFBPFilterType(Enum):
     RAMLAK = "ramlak"
     SHEPP_LOGAN = "shepp-logan"
     COSINE = "cosine"
@@ -368,12 +369,12 @@ class _NabuFBPFilterType(_Enum):
     HILBERT = "hilbert"
 
 
-class _NabuPaddingType(_Enum):
+class _NabuPaddingType(Enum):
     ZEROS = "zeros"
     EDGES = "edges"
 
 
-class RingCorrectionMethod(_Enum):
+class RingCorrectionMethod(Enum):
     NONE = "None"
     MUNCH = "munch"
     VO = "vo"
@@ -408,6 +409,9 @@ def nabu_std_err_has_error(errs: bytes | None):
             or " unable to import 'siphash24.siphash13" in line
             or "_create_built_program_from_source_cached" in line
             or "prg.build(options_bytes," in line
+            or (
+                "Performing MLEM" in line and "iterations" in line
+            )  # corrct usage of tqdm (goes to stderr)
         )
 
     if errs is None:

tomwer/core/process/reconstruction/normalization/normalization.py

@@ -140,7 +140,7 @@ class SinoNormalizationTask(
         if calc_fct is None:
             raise ValueError("calc_fct should be provided")
         else:
-            calc_fct = _ValueCalculationFct.from_value(calc_fct)
+            calc_fct = _ValueCalculationFct(calc_fct)
 
         try:
             value = self._cache_compute_from_manual_roi(

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

@@ -4,7 +4,7 @@ material for radio and sinogram normalization
 """
 from __future__ import annotations
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomoscan.normalization import Method
 
 
@@ -39,7 +39,7 @@ class _DatasetInfos:
 
     @scope.setter
     def scope(self, scope: str | _DatasetScope):
-        self._scope = _DatasetScope.from_value(scope)
+        self._scope = _DatasetScope(scope)
 
     @property
     def file_path(self):
@@ -86,7 +86,7 @@ class SinoNormalizationParams:
     def method(self, method: str | Method | None):
         if method is None:
             method = Method.NONE
-        self._method = Method.from_value(method)
+        self._method = Method(method)
 
     @property
     def source(self):
@@ -96,7 +96,7 @@ class SinoNormalizationParams:
     def source(self, source):
         if source is None:
             source = _ValueSource.NONE
-        self._source = _ValueSource.from_value(source)
+        self._source = _ValueSource(source)
 
     @property
     def extra_infos(self):

tomwer/core/process/reconstruction/output.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import os
 import logging
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomwer.io.utils.raw_and_processed_data import (
     to_processed_data_path,
 )
@@ -30,7 +30,7 @@ class NabuOutputFileFormat(_Enum):
     def from_value(cls, value):
         if isinstance(value, str):
             value = value.lstrip(".")
-        return super().from_value(value)
+        return NabuOutputFileFormat(value)
 
 
 def get_file_format(file_str):

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Iterable
 
 import numpy
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.reconstruction.scores.params import SABaseParams
 
@@ -56,7 +56,7 @@ class SAAxisParams(SABaseParams):
 
     @mode.setter
     def mode(self, mode):
-        mode = ReconstructionMode.from_value(mode)
+        mode = ReconstructionMode(mode)
         self._mode = mode
 
     @property
@@ -91,7 +91,7 @@ class SAAxisParams(SABaseParams):
         if "n_reconstruction" in dict_:
             self.n_reconstruction = dict_["n_reconstruction"]
         if "mode" in dict_:
-            self.mode = ReconstructionMode.from_value(dict_["mode"])
+            self.mode = ReconstructionMode(dict_["mode"])
 
     @staticmethod
     def from_dict(dict_):

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

@@ -430,7 +430,7 @@ class SAAxisTask(
             params.image_width = scan.dim_1
         scan.saaxis_params = params
 
-        mode = ReconstructionMode.from_value(params.mode)
+        mode = ReconstructionMode(params.mode)
         if mode is not ReconstructionMode.VERTICAL:
             raise ValueError(f"{mode} is not handled for now")
 
@@ -628,6 +628,10 @@ class SAAxisTask(
 
         saaxis_results_url = SAAxisTask.get_results_url(scan=scan)
 
+        if not os.path.exists(saaxis_results_url.file_path()):
+            _logger.error("no result saved")
+            return
+
         # save it to the file
         with HDF5File(saaxis_results_url.file_path(), mode="a") as h5f:
             nx_process = h5f.require_group(saaxis_results_url.data_path())

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

@@ -102,7 +102,7 @@ class SABaseParams:
 
     @score_method.setter
     def score_method(self, method):
-        self._score_method = ScoreMethod.from_value(method)
+        self._score_method = ScoreMethod(method)
 
     @property
     def scores(self) -> dict | None:
@@ -170,7 +170,7 @@ class SABaseParams:
                 output_dir = None
             self.output_dir = output_dir
         if "score_method" in dict_:
-            self.score_method = ScoreMethod.from_value(dict_["score_method"])
+            self.score_method = ScoreMethod(dict_["score_method"])
         if "cluster_config" in dict_:
             if dict_["cluster_config"] in (None, ""):
                 self.cluster_config = None

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

@@ -4,7 +4,7 @@ import logging
 import sys
 
 import numpy
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 _logger = logging.getLogger(__name__)
 
@@ -36,7 +36,7 @@ class ComputedScore:
         return self._tomo_consistency
 
     def get(self, method: ScoreMethod):
-        method = ScoreMethod.from_value(method)
+        method = ScoreMethod(method)
         if method is ScoreMethod.TV:
             return self.total_variation / float(10e5)
         elif method is ScoreMethod.TV_INVERSE:
@@ -135,7 +135,7 @@ def compute_score(
     :param method:
     :return: score of the frame
     """
-    method = ScoreMethod.from_value(method)
+    method = ScoreMethod(method)
     if data.ndim == 3:
         if data.shape[0] == 1:
             data = data.reshape(data.shape[1], data.shape[2])

tomwer/core/process/reconstruction/tests/test_axis.py

@@ -40,7 +40,7 @@ def test_read_x_rotation_axis_pixel_position(nxtomo_scan_360):  # noqa F811
     with h5py.File(nxtomo_scan_360.master_file, mode="a") as h5f:
         h5f[x_rotation_axis_pixel_position_path] = 12.5
 
-    nxtomo_scan_360.clear_caches()
+    nxtomo_scan_360.clear_cache()
     task.run()
     assert nxtomo_scan_360.axis_params.absolute_cor_value == 22.5
     assert nxtomo_scan_360.axis_params.relative_cor_value == 12.5

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

@@ -3,9 +3,7 @@ from __future__ import annotations
 
 
 import os
-import shutil
-import tempfile
-import unittest
+import pytest
 
 import numpy
 
@@ -18,74 +16,66 @@ from tomwer.core.process.reconstruction.scores.scores import (
 from tomwer.core.utils.scanutils import MockNXtomo
 
 
-class TestScoreFunctions(unittest.TestCase):
-    """Test all the score functions"""
+def test_img_contrast_std_score():
+    """simple test of the API to call compute_score_contrast_std"""
+    data = numpy.random.random(100 * 100).reshape(100, 100)
+    compute_score_contrast_std(data)
 
-    def test_img_contrast_std_score(self):
-        """simple test of the API to call compute_score_contrast_std"""
-        data = numpy.random.random(100 * 100).reshape(100, 100)
-        compute_score_contrast_std(data)
 
-    def test_method_to_function(self):
-        """Test the dictionary used to for linking the score method to the
-        callback function"""
-        data = numpy.random.random(100 * 100).reshape(100, 100)
-        for method_name, fct in _METHOD_TO_FCT.items():
-            with self.subTest(method_name=method_name, fct=fct):
-                res = fct(data)
-                self.assertFalse(res is None)
-                self.assertTrue(isinstance(res, float))
+@pytest.mark.parametrize("fct", _METHOD_TO_FCT.values())
+def test_method_to_function(fct):
+    """Test the dictionary used to for linking the score method to the
+    callback function"""
+    data = numpy.random.random(100 * 100).reshape(100, 100)
+    res = fct(data)
+    assert res is not None
+    assert isinstance(res, float)
 
 
-class TestSAAxisProcess(unittest.TestCase):
+def testSAAxisProcess(tmp_path):
     """Test the SAAxisProcess class"""
+    scan_path = tmp_path / "mock_nxtomo"
+    scan_path.mkdir()
+    # set up
+    dim = 10
+    mock = MockNXtomo(
+        scan_path=scan_path, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
+    )
+    mock.add_alignment_radio(index=10, angle=90)
+    mock.add_alignment_radio(index=10, angle=0)
+    scan = mock.scan
 
-    def setUp(self) -> None:
-        self.tempdir = tempfile.mkdtemp()
-        dim = 10
-        mock = MockNXtomo(
-            scan_path=self.tempdir, n_proj=10, n_ini_proj=10, scan_range=180, dim=dim
-        )
-        mock.add_alignment_radio(index=10, angle=90)
-        mock.add_alignment_radio(index=10, angle=0)
-        self.scan = mock.scan
+    default_saaxis_params = SAAxisParams()
+    default_saaxis_params.output_dir = os.path.join(scan_path, "output_dir")
+    default_saaxis_params.slice_indexes = {"slice": 4}
+    default_saaxis_params.nabu_config = {}
+    default_saaxis_params.dry_run = True
+    default_saaxis_params.file_format = "hdf5"
 
-        self._default_saaxis_params = SAAxisParams()
-        self._default_saaxis_params.output_dir = os.path.join(
-            self.tempdir, "output_dir"
-        )
-        self._default_saaxis_params.slice_indexes = {"slice": 4}
-        self._default_saaxis_params.nabu_config = {}
-        self._default_saaxis_params.dry_run = True
-        self._default_saaxis_params.file_format = "hdf5"
+    # test processing
+    process = SAAxisTask(
+        inputs={
+            "data": scan,
+            "sa_axis_params": default_saaxis_params.to_dict(),
+            "serialize_output_data": False,
+        }
+    )
 
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tempdir)
-
-    def test(self):
-        process = SAAxisTask(
-            inputs={
-                "data": self.scan,
-                "sa_axis_params": self._default_saaxis_params.to_dict(),
-                "serialize_output_data": False,
-            }
-        )
-
-        self._default_saaxis_params.estimated_cor = 11
-        self._default_saaxis_params.research_width = 2
-        process = SAAxisTask(
-            inputs={
-                "data": self.scan,
-                "sa_axis_params": self._default_saaxis_params.to_dict(),
-                "serialize_output_data": False,
-            },
-        )
-        process.run()
-        process = SAAxisTask(
-            inputs={
-                "data": self.scan,
-                "sa_axis_params": self._default_saaxis_params.to_dict(),
-                "serialize_output_data": False,
-            },
-        )
-        process.run()
+    default_saaxis_params.estimated_cor = 11
+    default_saaxis_params.research_width = 2
+    process = SAAxisTask(
+        inputs={
+            "data": scan,
+            "sa_axis_params": default_saaxis_params.to_dict(),
+            "serialize_output_data": False,
+        },
+    )
+    process.run()
+    process = SAAxisTask(
+        inputs={
+            "data": scan,
+            "sa_axis_params": default_saaxis_params.to_dict(),
+            "serialize_output_data": False,
+        },
+    )
+    process.run()

tomwer/core/process/stitching/metadataholder.py

@@ -41,19 +41,19 @@ class StitchingMetadata:
         if value is not None and not isinstance(
             value, (float, numpy.float32, numpy.float64)
         ):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pixel_or_voxel_size[axis] = value
 
     def setPxPos(self, value, axis):
         if value is not None and not isinstance(value, (int, numpy.int32)):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pos_as_px[axis] = value
 
     def setMetricPos(self, value, axis):
         if value is not None and not isinstance(
             value, (int, numpy.float32, numpy.float64, float)
         ):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pos_as_m[axis] = value
 
     def get_raw_position_m(self, axis):
@@ -111,9 +111,9 @@ class StitchingMetadata:
             return self._pixel_or_voxel_size[axis]
         elif isinstance(self.tomo_obj, TomoScanBase):
             if axis == 0:
-                return self.tomo_obj.y_pixel_size
+                return self.tomo_obj.sample_y_pixel_size
             elif axis in (1, 2):
-                return self.tomo_obj.x_pixel_size
+                return self.tomo_obj.sample_x_pixel_size
             else:
                 raise TypeError(f"axis is expected to be in (0, 1, 2). {axis} provided")
         elif isinstance(self.tomo_obj, VolumeBase):

tomwer/core/process/stitching/nabustitcher.py

@@ -162,12 +162,9 @@ class StitchingPostProcAggregation(_StitchingPostProcAggregation):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        print("creates StitchingPostProcAggregation")
 
         if isinstance(self.stitching_config, dict):
-            stitching_type = StitchingType.from_value(
-                self.stitching_config["stitching"]["type"]
-            )
+            stitching_type = StitchingType(self.stitching_config["stitching"]["type"])
             if stitching_type is StitchingType.Z_PREPROC:
                 self._stitching_config = PreProcessedZStitchingConfiguration.from_dict(
                     self.stitching_config

tomwer/core/process/tests/test_normalization.py

@@ -54,7 +54,8 @@ class TestNormalization(unittest.TestCase):
             "median": numpy.array([800.5, 10800.5]),
         }
 
-        for calc_fct in params._ValueCalculationFct.values():
+        for item in params._ValueCalculationFct:
+            calc_fct = item.value
             with self.subTest(calc_fct=calc_fct):
                 process_params.extra_infos = {
                     "start_x": 0,

tomwer/core/scan/edfscan.py

@@ -127,9 +127,9 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             )
         return EDFTomoScan(scan=identifier.folder)
 
-    def clear_caches(self):
-        _tsEDFTomoScan.clear_caches(self)
-        TomwerScanBase.clear_caches(self)
+    def clear_cache(self):
+        _tsEDFTomoScan.clear_cache(self)
+        TomwerScanBase.clear_cache(self)
 
     @staticmethod
     def directory_contains_scan(directory, src_pattern, dest_pattern):