tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

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

@@ -32,6 +32,7 @@ from typing import Optional, Union
 
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.process.reconstruction.scores.scores import ScoreMethod
+from tomwer.core.utils.deprecation import deprecated
 
 
 class SABaseParams:
@@ -42,7 +43,7 @@ class SABaseParams:
     def __init__(self):
         self._n_reconstruction = 20
         self._slice_indexes = "middle"
-        self._nabu_params = {}
+        self._nabu_recons_params = {}
         self._dry_run = False
         self._output_dir = None
         self._score_method = ScoreMethod.TV
@@ -85,14 +86,24 @@ class SABaseParams:
         self._slice_indexes = indexes
 
     @property
+    def nabu_recons_params(self) -> dict:
+        return self._nabu_recons_params
+
+    @nabu_recons_params.setter
+    def nabu_recons_params(self, params: dict):
+        if not isinstance(params, dict):
+            raise TypeError(f"params should be a dictionary and not {type(params)}")
+        self._nabu_recons_params = params
+
+    @property
+    @deprecated(replacement="nabu_recons_params", since_version="1.2")
     def nabu_params(self) -> dict:
-        return self._nabu_params
+        return self.nabu_recons_params
 
     @nabu_params.setter
+    @deprecated(replacement="nabu_recons_params", since_version="1.2")
     def nabu_params(self, params: dict):
-        if not isinstance(params, dict):
-            raise TypeError(f"params should be a dictionary and not {type(params)}")
-        self._nabu_params = params
+        self.nabu_recons_params = params
 
     @property
     def dry_run(self) -> bool:
@@ -161,7 +172,7 @@ class SABaseParams:
     def to_dict(self) -> dict:
         return {
             "slice_index": self.slice_indexes or "",
-            "nabu_params": self.nabu_params,
+            "nabu_params": self.nabu_recons_params,
             "dry_run": self.dry_run,
             "output_dir": self.output_dir or "",
             "score_method": self.score_method.value,
@@ -177,7 +188,7 @@ class SABaseParams:
                 slice_index = None
             self.slice_indexes = slice_index
         if "nabu_params" in dict_:
-            self.nabu_params = dict_["nabu_params"]
+            self.nabu_recons_params = dict_["nabu_params"]
         if "dry_run" in dict_:
             self.dry_run = bool(dict_["dry_run"])
         if "output_dir" in dict_:
@@ -195,4 +206,6 @@ class SABaseParams:
 
     @staticmethod
     def from_dict(dict_):
-        raise ValueError("Base class")
+        res = SABaseParams()
+        res.load_from_dict(dict_=dict_)
+        return res

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

@@ -58,6 +58,7 @@ def test_register_and_copy_darks_and_flats(
             "save_dir": save_dir,
             "process_only_copy": process_only_copy_scan_with_raw,
             "process_only_dkrf": process_only_dkrf_scan_with_raw,
+            "serialize_output_data": False,
         }
     )
     # test processing with flat and dark materials
@@ -76,6 +77,7 @@ def test_register_and_copy_darks_and_flats(
             "save_dir": save_dir,
             "process_only_copy": process_only_copy_scan_without_raw,
             "process_only_dkrf": process_only_dkrf_scan_without_raw,
+            "serialize_output_data": False,
         }
     )
 

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

@@ -36,7 +36,7 @@ import unittest
 import numpy
 
 from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
+from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisTask
 from tomwer.core.process.reconstruction.scores.scores import (
     _METHOD_TO_FCT,
     compute_score_contrast_std,
@@ -89,17 +89,30 @@ class TestSAAxisProcess(unittest.TestCase):
         shutil.rmtree(self.tempdir)
 
     def test(self):
-        process = SAAxisProcess(inputs={"data": self.scan})
-        with self.assertRaises(Exception):
-            process.run()
-        process.set_configuration(self._default_saaxis_params)
+        process = SAAxisTask(
+            inputs={
+                "data": self.scan,
+                "sa_axis_params": self._default_saaxis_params.to_dict(),
+                "serialize_output_data": False,
+            }
+        )
         with self.assertRaises(ValueError):
             process.run()
         self._default_saaxis_params.estimated_cor = 11
         self._default_saaxis_params.research_width = 2
-        process.set_configuration(self._default_saaxis_params)
+        process = SAAxisTask(
+            inputs={
+                "data": self.scan,
+                "sa_axis_params": self._default_saaxis_params.to_dict(),
+                "serialize_output_data": False,
+            },
+        )
         process.run()
-        process = SAAxisProcess(
-            inputs={"data": self.scan, "sa_axis_params": self._default_saaxis_params}
+        process = SAAxisTask(
+            inputs={
+                "data": self.scan,
+                "sa_axis_params": self._default_saaxis_params.to_dict(),
+                "serialize_output_data": False,
+            },
         )
         process.run()

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

@@ -35,7 +35,7 @@ import unittest
 
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaParams,
-    SADeltaBetaProcess,
+    SADeltaBetaTask,
 )
 from tomwer.core.utils.scanutils import MockHDF5
 
@@ -57,7 +57,13 @@ class TestSADeltaBetaProcess(unittest.TestCase):
         super().tearDown()
 
     def test(self):
-        process = SADeltaBetaProcess(inputs={"data": self.scan})
+        process = SADeltaBetaTask(
+            inputs={
+                "data": self.scan,
+                "sa_delta_beta_params": SADeltaBetaParams().to_dict(),
+                "serialize_output_data": False,
+            }
+        )
 
         default_sadelta_beta_params = SADeltaBetaParams()
         default_sadelta_beta_params.output_dir = os.path.join(
@@ -65,7 +71,4 @@ class TestSADeltaBetaProcess(unittest.TestCase):
         )
         default_sadelta_beta_params.dry_run = True
 
-        with self.assertRaises(Exception):
-            process.run()
-        process.set_configuration(default_sadelta_beta_params)
         process.run()

tomwer/core/process/script/python.py

@@ -43,7 +43,9 @@ _logger = logging.getLogger(__name__)
 
 
 class PythonScript(
-    Task, optional_input_names=("data", "volume"), output_names=("data", "volume")
+    Task,
+    optional_input_names=("data", "volume", "serialize_output_data"),
+    output_names=("data", "volume"),
 ):
     def run(self):
         # load data
@@ -82,7 +84,10 @@ class PythonScript(
         except Exception as e:
             _logger.error("Fail to register process. Error is " + str(e))
 
-        self.outputs.data = out_data
+        if out_data is not None and self.get_input_value("serialize_output_data", True):
+            self.outputs.data = out_data.to_dict()
+        else:
+            self.outputs.data = out_data
         self.outputs.volume = out_volume
 
     @staticmethod

tomwer/core/process/stitching/nabustitcher.py

@@ -34,7 +34,11 @@ class StitcherTask(
     Task,
     SuperviseProcess,
     input_names=("stitching_config",),
-    optional_input_names=("cluster_config", "progress"),
+    optional_input_names=(
+        "cluster_config",
+        "progress",
+        "serialize_output_data",
+    ),
     output_names=(
         "data",
         "future_tomo_obj",
@@ -65,7 +69,10 @@ class StitcherTask(
                 nx_tomo = ScanFactory.create_tomo_object_from_identifier(
                     stitched_identifier.to_str()
                 )
-                self.outputs.data = nx_tomo
+                if self.get_input_value("serialize_output_data", True):
+                    self.outputs.data = nx_tomo.to_dict()
+                else:
+                    self.outputs.data = nx_tomo
                 self.outputs.volume = None
                 self.outputs.future_tomo_obj = None
             elif config.stitching_type is StitchingType.Z_POSTPROC:
@@ -96,7 +103,7 @@ class StitcherTask(
             # handle post processing
             data_aggregation = StitchingPostProcAggregation(
                 futures=futures,
-                stitching_config=stitching_config,
+                stitching_config=config,
             )
             for future in futures.values():
                 # TODO: do we ned to make sure the processing is not finished yet ?

tomwer/core/process/task.py

@@ -72,11 +72,12 @@ class BaseProcessInfo:
         self._scheme_title = (
             "scheme_title"  # TODO: have a look, this must be get somewhere and reused ?
         )
-        self._return_dict = inputs.get("return_dict", False)
 
         """should the return type of the handler should be TomoBase instance
         objects or dict"""
         self._settings = {}
+        self._cancelled = False
+        # a useful variable that can be set to True if the task has been cancelled
 
     @staticmethod
     def properties_help():
@@ -401,14 +402,6 @@ class BaseProcessInfo:
                     )
         return processes
 
-    def _set_return_dict(self, return_dict):
-        """
-
-        :param bool return_dict: if True, force the process to return a dict
-                                 instead of a `.TomoBase` object
-        """
-        self._return_dict = return_dict
-
 
 class TaskWithProgress(_EwoksTaskWithProgress, BaseProcessInfo):
     """Class from which all tomwer process should inherit

tomwer/core/process/test/test_axis.py

@@ -45,7 +45,7 @@ from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF, MockHDF5
 from tomwer.tests.utils import UtilsTest
 
-from ..reconstruction.axis.axis import AxisProcess
+from ..reconstruction.axis.axis import AxisTask
 
 
 class TestAxisIO(unittest.TestCase):
@@ -76,19 +76,19 @@ class TestAxisIO(unittest.TestCase):
     def testInputOutput(self):
         """Test that io using TomoBase instance work"""
         for input_type in (dict, TomwerScanBase):
-            for return_dict in (True, False):
+            for serialize_output_data in (True, False):
                 with self.subTest(
-                    return_dict=return_dict,
+                    serialize_output_data=serialize_output_data,
                     input_type=input_type,
                 ):
                     input_obj = self.scan
                     if input_obj is dict:
                         input_obj = input_obj.to_dict()
-                    axis_process = AxisProcess(
+                    axis_process = AxisTask(
                         inputs={
                             "axis_params": self.recons_params,
                             "data": input_obj,
-                            "return_dict": return_dict,
+                            "serialize_output_data": serialize_output_data,
                         }
                     )
 
@@ -99,7 +99,7 @@ class TestAxisIO(unittest.TestCase):
 
                     axis_process.run()
                     out = axis_process.outputs.data
-                    if return_dict:
+                    if serialize_output_data:
                         self.assertTrue(isinstance(out, dict))
                     else:
                         self.assertTrue(isinstance(out, TomwerScanBase))
@@ -120,10 +120,11 @@ class TestAxis(unittest.TestCase):
         mock = MockEDF(scan_path=self.tempdir, n_radio=10, n_ini_radio=10)
         scan = EDFTomoScan(mock.scan_path)
         self.recons_params.mode = "centered"
-        axis_process = AxisProcess(
+        axis_process = AxisTask(
             inputs={
                 "data": scan,
                 "axis_params": self.recons_params,
+                "serialize_output_data": False,
             }
         )
 
@@ -141,7 +142,7 @@ class TestAxis(unittest.TestCase):
             axis_value = h5py_read_dataset(group_axis["results"]["center_of_rotation"])
 
         processes = Task.get_processes_frm_type(
-            process_file=scan.process_file, process_type=AxisProcess, entry="entry"
+            process_file=scan.process_file, process_type=AxisTask, entry="entry"
         )
         self.assertEqual(len(processes), 1)
         self.assertEqual(processes[0].results["center_of_rotation"], axis_value)
@@ -171,10 +172,11 @@ class TestAxis(unittest.TestCase):
         self.recons_params.mode = "centered"
 
         # check data url take
-        axis_process = AxisProcess(
+        axis_process = AxisTask(
             inputs={
                 "data": scan,
                 "axis_params": self.recons_params,
+                "serialize_output_data": False,
             }
         )
         axis_process.run()
@@ -192,7 +194,7 @@ class TestAxis(unittest.TestCase):
             axis_value = h5py_read_dataset(group_axis["results"]["center_of_rotation"])
         self.assertTrue(-dim / 2 <= axis_value <= dim / 2)
         processes = Task.get_processes_frm_type(
-            process_file=scan.process_file, process_type=AxisProcess
+            process_file=scan.process_file, process_type=AxisTask
         )
         self.assertEqual(len(processes), 1)
         self.assertEqual(processes[0].results["center_of_rotation"], axis_value)
@@ -268,7 +270,7 @@ class TestSinogramAlgorithm(unittest.TestCase):
 
     def test_growing_window_sinogram(self):
         recons_params = AxisRP()
-        axis_process = AxisProcess(
+        axis_process = AxisTask(
             inputs={"axis_params": recons_params, "data": self.scan}
         )
         recons_params.mode = AxisMode.growing_window_sinogram
@@ -278,8 +280,12 @@ class TestSinogramAlgorithm(unittest.TestCase):
 
     def test_sliding_window(self):
         recons_params = AxisRP()
-        axis_process = AxisProcess(
-            inputs={"axis_params": recons_params, "data": self.scan}
+        axis_process = AxisTask(
+            inputs={
+                "axis_params": recons_params,
+                "data": self.scan,
+                "serialize_output_data": False,
+            }
         )
         recons_params.mode = AxisMode.sliding_window_sinogram
         recons_params.side = "left"
@@ -289,8 +295,12 @@ class TestSinogramAlgorithm(unittest.TestCase):
 
     def test_sino_coarse_to_fine(self):
         recons_params = AxisRP()
-        axis_process = AxisProcess(
-            inputs={"axis_params": recons_params, "data": self.scan}
+        axis_process = AxisTask(
+            inputs={
+                "axis_params": recons_params,
+                "data": self.scan,
+                "serialize_output_data": False,
+            }
         )
         recons_params.mode = AxisMode.sino_coarse_to_fine
         recons_params.sinogram_subsampling = 1

tomwer/core/process/test/test_conditions.py

@@ -33,7 +33,7 @@ import tempfile
 import unittest
 
 from tomwer.core.process.conditions.filters import (
-    FileNameFilter,
+    FileNameFilterTask,
     RegularExpressionFilter,
 )
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -69,24 +69,24 @@ class TestConditionIO(unittest.TestCase):
 
     def testInputOutput(self):
         for input_type in (dict, TomwerScanBase):
-            for return_dict in (True, False):
+            for serialize_output_data in (True, False):
                 with self.subTest(
-                    return_dict=return_dict,
+                    return_dict=serialize_output_data,
                     input_type=input_type,
                 ):
                     input_obj = self.scan
                     if input_type is dict:
                         input_obj = self.scan.to_dict()
-                    filter_process = FileNameFilter(
+                    filter_process = FileNameFilterTask(
                         inputs={
                             "pattern": "*",
-                            "return_dict": return_dict,
+                            "serialize_output_data": serialize_output_data,
                             "data": input_obj,
                         }
                     )
                     filter_process.run()
                     out = filter_process.outputs.data
-                    if return_dict:
+                    if serialize_output_data:
                         self.assertTrue(isinstance(out, dict))
                     else:
                         self.assertTrue(isinstance(out, TomwerScanBase))

tomwer/core/process/test/test_dark_and_flat.py

@@ -43,7 +43,7 @@ from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF, MockHDF5
 from tomwer.tests.utils import UtilsTest
 
-from ..reconstruction.darkref.darkrefs import DarkRefs
+from ..reconstruction.darkref.darkrefs import DarkRefsTask
 from ..reconstruction.darkref.darkrefscopy import DarkRefsCopy
 
 
@@ -69,25 +69,25 @@ class TestDarkRefIO(unittest.TestCase):
             (self.scan_edf, self.scan_hdf5), ("edf scan", "hdf5 scan")
         ):
             for input_type in (dict, TomwerScanBase):
-                for return_dict in (True, False):
+                for serialize_output_data in (True, False):
                     with self.subTest(
-                        return_dict=return_dict,
+                        return_dict=serialize_output_data,
                         input_type=input_type,
                         scan_type=scan_type,
                     ):
                         input_obj = scan
                         if input_obj is dict:
                             input_obj = input_obj.to_dict()
-                        process = DarkRefs(
+                        process = DarkRefsTask(
                             inputs={
                                 "dark_ref_params": self.recons_params,
                                 "data": input_obj,
-                                "return_dict": return_dict,
+                                "serialize_output_data": serialize_output_data,
                             }
                         )
                         process.run()
                         out = process.outputs.data
-                        if return_dict:
+                        if serialize_output_data:
                             self.assertTrue(isinstance(out, dict))
                         else:
                             self.assertTrue(isinstance(out, TomwerScanBase))
@@ -116,9 +116,9 @@ class TestDarkRefCopyIO(unittest.TestCase):
             (self.scan_edf, self.scan_hdf5), ("edf scan", "hdf5 scan")
         ):
             for input_type in (dict, TomwerScanBase):
-                for return_dict in (True, False):
+                for serialize_output_data in (True, False):
                     with self.subTest(
-                        return_dict=return_dict,
+                        return_dict=serialize_output_data,
                         input_type=input_type,
                         scan_type=scan_type,
                     ):
@@ -129,13 +129,13 @@ class TestDarkRefCopyIO(unittest.TestCase):
                             inputs={
                                 "dark_ref_params": self.recons_params,
                                 "data": input_obj,
-                                "return_dict": return_dict,
+                                "serialize_output_data": serialize_output_data,
                                 "save_dir": self._save_dir,
                             }
                         )
                         dkrf_process.run()
                         out = dkrf_process.outputs.data
-                        if return_dict:
+                        if serialize_output_data:
                             self.assertTrue(isinstance(out, dict))
                         else:
                             self.assertTrue(isinstance(out, TomwerScanBase))
@@ -195,10 +195,11 @@ class TestDarkRefEdf(unittest.TestCase):
             with self.subTest(method=method):
                 if os.path.exists(self.scan.process_file):
                     os.remove(self.scan.process_file)
-                process = DarkRefs(
+                process = DarkRefsTask(
                     inputs={
                         "dark_ref_params": self.recons_params,
                         "data": self.scan,
+                        "serialize_output_data": False,
                     }
                 )
 
@@ -231,10 +232,11 @@ class TestDarkRefEdf(unittest.TestCase):
                     os.remove(self.scan.process_file)
                 self.recons_params.dark_calc_method = cMethod.NONE
                 self.recons_params.flat_calc_method = method
-                process = DarkRefs(
+                process = DarkRefsTask(
                     inputs={
                         "dark_ref_params": self.recons_params,
                         "data": self.scan,
+                        "serialize_output_data": False,
                     }
                 )
                 process.run()
@@ -278,10 +280,11 @@ class TestDarkRefNx(unittest.TestCase):
             with self.subTest(method=method):
                 self.recons_params.dark_calc_method = method
                 self.recons_params.flat_calc_method = cMethod.NONE
-                process = DarkRefs(
+                process = DarkRefsTask(
                     inputs={
                         "dark_ref_params": self.recons_params,
                         "data": self.scan,
+                        "serialize_output_data": False,
                     }
                 )
                 process.run()
@@ -326,10 +329,11 @@ class TestDarkRefNx(unittest.TestCase):
 
                 self.recons_params.dark_calc_method = cMethod.NONE
                 self.recons_params.flat_calc_method = method
-                process = DarkRefs(
+                process = DarkRefsTask(
                     inputs={
                         "dark_ref_params": self.recons_params,
                         "data": self.scan,
+                        "serialize_output_data": False,
                     }
                 )
                 process.run()
@@ -364,10 +368,11 @@ class TestDarkRefNx(unittest.TestCase):
 
         expected_flats_s1 = numpy.median(data_flat_serie_1, axis=0)
         expected_flats_s2 = numpy.median(data_flat_serie_2, axis=0)
-        process = DarkRefs(
+        process = DarkRefsTask(
             inputs={
                 "dark_ref_params": self.recons_params,
                 "data": self.scan,
+                "serialize_output_data": False,
             }
         )
         process.run()

tomwer/core/process/test/test_data_transfer.py

@@ -45,7 +45,7 @@ from tomoscan.io import HDF5File
 from tomoscan.validator import is_valid_for_reconstruction
 
 from tomwer.core.process.control.datalistener import DataListener
-from tomwer.core.process.control.scantransfer import ScanTransfer
+from tomwer.core.process.control.scantransfer import ScanTransferTask
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF
@@ -70,9 +70,9 @@ class TestDataTransferIO(unittest.TestCase):
     def testInputOutput(self):
         """Test that io using TomoBase instance work"""
         for input_type in (dict, TomwerScanBase):
-            for return_dict in (True, False):
+            for serialize_output_data in (True, False):
                 with self.subTest(
-                    return_dict=return_dict,
+                    return_dict=serialize_output_data,
                     input_type=input_type,
                 ):
                     output_folder = tempfile.mkdtemp()
@@ -91,11 +91,11 @@ class TestDataTransferIO(unittest.TestCase):
                         dim=10,
                     )
 
-                    transfert_process = ScanTransfer(
+                    transfert_process = ScanTransferTask(
                         inputs={
                             "data": scan,
                             "dest_dir": output_folder,
-                            "return_dict": return_dict,
+                            "serialize_output_data": serialize_output_data,
                         }
                     )
 
@@ -105,7 +105,7 @@ class TestDataTransferIO(unittest.TestCase):
                         input_obj = input_obj.to_dict()
                     transfert_process.run()
                     out = transfert_process.outputs.data
-                    if return_dict:
+                    if serialize_output_data:
                         self.assertTrue(isinstance(out, dict))
                     else:
                         self.assertTrue(isinstance(out, TomwerScanBase))
@@ -175,7 +175,7 @@ class TestBlissDataTransfer(unittest.TestCase):
         for scan_path in out_not_included_scans:
             self.assertFalse(os.path.exists(scan_path))
 
-        process = ScanTransfer(
+        process = ScanTransferTask(
             inputs={
                 "data": self.scan,
                 "block": True,
@@ -321,7 +321,7 @@ class NXTomoDataTransferBase(unittest.TestCase):
     def _test(self):
         src_scan = HDF5TomoScan(self.nexus_file_path, entry="entry0000")
         assert is_valid_for_reconstruction(src_scan)
-        process = ScanTransfer(
+        process = ScanTransferTask(
             inputs={
                 "data": src_scan,
                 "turn_off_print": True,

tomwer/core/process/test/test_data_watcher.py

@@ -53,7 +53,7 @@ def test_data_watcher_io(tmp_path, det_method):
     )
     data_watcher_process.setFolderObserved(str(tmp_path / "folder"))
     data_watcher_process.clear_output_values()
-    data_watcher_process._set_return_dict(True)
+    data_watcher_process.set_serialize_output_data(True)
     LoopThread.quitEvent.clear()
     data_watcher_process.start()
 

tomwer/core/process/test/test_lamino.py

@@ -35,7 +35,7 @@ import unittest
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.scanutils import MockEDF
 
-from ..reconstruction.lamino import LaminoReconstruction
+from ..reconstruction.lamino import LaminoReconstructionTask
 
 
 class TestLaminoIO(unittest.TestCase):
@@ -53,24 +53,24 @@ class TestLaminoIO(unittest.TestCase):
 
     def testInputOutput(self):
         for input_type in (dict, TomwerScanBase):
-            for return_dict in (True, False):
+            for serialize_output_data in (True, False):
                 with self.subTest(
-                    return_dict=return_dict,
+                    serialize_output_data=serialize_output_data,
                     input_type=input_type,
                 ):
                     input_obj = self.scan
                     if input_obj is dict:
                         input_obj = input_obj.to_dict()
-                    lamino_process = LaminoReconstruction(
+                    lamino_process = LaminoReconstructionTask(
                         inputs={
                             "dry_run": True,
-                            "return_dict": return_dict,
                             "data": input_obj,
+                            "serialize_output_data": serialize_output_data,
                         }
                     )
                     lamino_process.run()
                     out = lamino_process.outputs.data
-                    if return_dict:
+                    if serialize_output_data:
                         self.assertTrue(isinstance(out, dict))
                     else:
                         self.assertTrue(isinstance(out, TomwerScanBase))