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

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -32,45 +32,51 @@ __license__ = "MIT"
 __date__ = "28/10/2021"
 
 
-import os
 import logging
-import h5py
-import numpy
+import os
 from copy import copy
 from typing import Optional, Union
+
+import h5py
+import numpy
 from nabu.pipeline.config import get_default_nabu_config
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
-from processview.core.manager import ProcessManager, DatasetState
+from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
+from tomoscan.esrf.scan.utils import get_data
+from tomoscan.io import HDF5File
+
+import tomwer.version
 from tomwer.core.process.reconstruction.nabu.nabucommon import (
-    ResultSlurmRun,
     ResultsLocalRun,
+    ResultSlurmRun,
+    ResultsRun,
     ResultsWithStd,
 )
-from tomwer.core.scan.scanfactory import ScanFactory
-from .params import SADeltaBetaParams
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils import logconfig
-from tomwer.core.process.task import Task
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.io import HDF5File
-from tomoscan.esrf.scan.utils import get_data
-import tomwer.version
 from tomwer.core.process.reconstruction.nabu.nabuslices import (
+    SingleSliceRunner,
     run_single_slice_reconstruction,
 )
-from tomwer.core.process.reconstruction.nabu.nabucommon import ResultsRun
+from tomwer.core.process.reconstruction.scores import (
+    ComputedScore,
+    ScoreMethod,
+    apply_roi,
+    compute_score,
+    get_disk_mask_radius,
+)
+from tomwer.core.process.task import Task
 from tomwer.core.progress import Progress
-from ..nabu import utils as nabu_utils
-from tomwer.core.process.reconstruction.scores import compute_score
-from tomwer.core.process.reconstruction.scores import ScoreMethod
-from tomwer.core.process.reconstruction.scores import ComputedScore
-from tomwer.core.process.reconstruction.scores import get_disk_mask_radius, apply_roi
-from tomwer.core.process.reconstruction.nabu.nabuslices import SingleSliceRunner
-from tomwer.core.volume.volumefactory import VolumeFactory
+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 logconfig
 from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.volume.volumefactory import VolumeFactory
+
+from ..nabu import utils as nabu_utils
+from .params import SADeltaBetaParams
 
 _logger = logging.getLogger(__name__)
 
@@ -113,22 +119,20 @@ def one_slice_several_db(
     dry_run = configuration.dry_run
     cluster_config = configuration.cluster_config
     _logger.info(
-        "launch reconstruction of slice {} and delta / beta: {}".format(
-            slice_index, delta_beta_s
-        )
+        f"launch reconstruction of slice {slice_index} and delta / beta: {delta_beta_s}"
     )
     if isinstance(slice_index, str):
         if not slice_index == "middle":
-            raise ValueError("slice index {} not recognized".format(slice_index))
+            raise ValueError(f"slice index {slice_index} not recognized")
     elif not len(slice_index) == 1:
         raise ValueError("only manage one slice")
     else:
         slice_index = list(slice_index.values())[0]
-    advancement = Progress("sa-delta-beta - slice {} of {}".format(slice_index, scan))
+    advancement = Progress(f"sa-delta-beta - slice {slice_index} of {scan}")
 
     config = configuration.nabu_params.copy()
 
-    _logger.info("start reconstruction of {}".format(str(scan)))
+    _logger.info(f"start reconstruction of {scan}")
     # if scan contains some center of position copy it to nabu
     if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
         if "reconstruction" in config:
@@ -136,7 +140,7 @@ def one_slice_several_db(
             cor_nabu_ref = scan.axis_params.relative_cor_value + scan.dim_1 / 2.0
             config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
 
-    _logger.info("set nabu reconstruction parameters to {}".format(str(scan)))
+    _logger.info(f"set nabu reconstruction parameters to {scan}")
     scan.nabu_recons_params = config
 
     db_reconstructions = {}
@@ -285,8 +289,7 @@ def one_slice_several_db(
                     data = get_data(slice_url)
                 except Exception as e:
                     _logger.error(
-                        "Fail to compute a score for {}. Reason is {}"
-                        "".format(volume_identifier, str(e))
+                        f"Fail to compute a score for {volume_identifier}. Reason is {e}"
                     )
                     datasets_[db] = (slice_url, None)
                 else:
@@ -297,14 +300,12 @@ def one_slice_several_db(
                             data = data.reshape(data.shape[0], data.shape[1])
                         else:
                             raise ValueError(
-                                "Data is expected to be 2D. Not {}".format(data.ndim)
+                                f"Data is expected to be 2D. Not {data.ndim}D"
                             )
                     elif data.ndim == 2:
                         pass
                     else:
-                        raise ValueError(
-                            "Data is expected to be 2D. Not {}".format(data.ndim)
-                        )
+                        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
 
                     datasets_[db] = (slice_url, data)
             return datasets_
@@ -411,9 +412,7 @@ class SADeltaBetaProcess(
         elif isinstance(scan, dict):
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
         # insure scan contains some parameter regarding sa delta / beta
         if scan.sa_delta_beta_params is None:
             scan.sa_delta_beta_params = SADeltaBetaParams()
@@ -458,18 +457,13 @@ class SADeltaBetaProcess(
             slice_index = self.get_configuration().get("slice_index", None)
 
             if db_res is None:
-                info = (
-                    "fail to compute delta/beta scores of slice {} for scan {}."
-                    "".format(slice_index, scan)
-                )
+                info = f"fail to compute delta/beta scores of slice {slice_index} for scan {scan}."
                 _logger.processFailed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan, process=self, state=DatasetState.FAILED, details=info
                 )
             else:
-                info = "delta/beta scores of slice {} for scan {} computed." "".format(
-                    slice_index, scan
-                )
+                info = f"delta/beta scores of slice {slice_index} for scan {scan} computed."
                 _logger.processSucceed(info, extra=extra)
                 ProcessManager().notify_dataset_state(
                     dataset=scan,
@@ -496,7 +490,7 @@ class SADeltaBetaProcess(
         if not isinstance(score_rois, dict):
             raise TypeError("score_rois is expected to be a dict")
         process_file = scan.process_file
-        process_name = "tomwer_process_" + str(process_index)
+        process_name = f"tomwer_process_{process_index}"
 
         if scan.saaxis_params.scores in (None, {}):
             return

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

@@ -1,6 +1,6 @@
-from .scores import ScoreMethod  # noqa F401
 from .params import SABaseParams  # noqa F401
-from .scores import compute_score  # noqa F401
 from .scores import ComputedScore  # noqa F401
+from .scores import ScoreMethod  # noqa F401
 from .scores import apply_roi  # noqa F401
+from .scores import compute_score  # noqa F401
 from .scores import get_disk_mask_radius  # noqa F401

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

@@ -28,10 +28,11 @@ __license__ = "MIT"
 __date__ = "04/05/2021"
 
 
-from tomwer.core.cluster.cluster import SlurmClusterConfiguration
-from tomwer.core.process.reconstruction.scores import ScoreMethod
 from typing import Optional, Union
 
+from tomwer.core.cluster.cluster import SlurmClusterConfiguration
+from tomwer.core.process.reconstruction.scores.scores import ScoreMethod
+
 
 class SABaseParams:
     """Parameters for the semi-automatic axis calculation"""
@@ -79,8 +80,7 @@ class SABaseParams:
                 raise ValueError("the only valid indexes values is 'middle'")
         elif not isinstance(indexes, (type(None), dict)):
             raise TypeError(
-                "index should be an instance of int or None and "
-                "not {}".format(type(indexes))
+                f"index should be an instance of int or None and not {type(indexes)}"
             )
         self._slice_indexes = indexes
 
@@ -91,9 +91,7 @@ class SABaseParams:
     @nabu_params.setter
     def nabu_params(self, params: dict):
         if not isinstance(params, dict):
-            raise TypeError(
-                "params should be a dictionary and not {}" "".format(type(params))
-            )
+            raise TypeError(f"params should be a dictionary and not {type(params)}")
         self._nabu_params = params
 
     @property
@@ -144,8 +142,7 @@ class SABaseParams:
             raise TypeError("format should be a str")
         if format_ not in self._VALID_FILE_FORMAT:
             raise ValueError(
-                "requested format ({}) is invalid. valid ones "
-                "are {}".format(format_, self._VALID_FILE_FORMAT)
+                f"requested format ({format_}) is invalid. valid ones are {self._VALID_FILE_FORMAT}"
             )
         self._file_format = format_
 

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

@@ -28,12 +28,13 @@ __license__ = "MIT"
 __date__ = "18/02/2021"
 
 
-from silx.utils.enum import Enum as _Enum
-import numpy
-import sys
 import logging
+import sys
 from typing import Union
 
+import numpy
+from silx.utils.enum import Enum as _Enum
+
 _logger = logging.getLogger(__name__)
 
 
@@ -76,7 +77,7 @@ class ComputedScore:
         elif method is ScoreMethod.TOMO_CONSISTENCY:
             return self.tomo_consistency
         else:
-            raise ValueError("{} is an unrecognized method".format(method))
+            raise ValueError(f"{method} is an unrecognized method")
 
 
 def compute_tomo_consistency(
@@ -160,11 +161,11 @@ def compute_score(
         elif data.shape[2] == 1:
             data = data.reshape(data.shape[0], data.shape[1])
         else:
-            raise ValueError("Data is expected to be 2D. Not {}".format(data.ndim))
+            raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
     elif data.ndim == 2:
         pass
     else:
-        raise ValueError("Data is expected to be 2D. Not {}".format(data.ndim))
+        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
     if method is ScoreMethod.TOMO_CONSISTENCY:
         try:
             return compute_tomo_consistency(
@@ -177,9 +178,7 @@ def compute_score(
         except ImportError:
             return None
         except Exception as e:
-            _logger.warning(
-                "Fail to compute 'tomo consistency' score. " "Reason is {}".format(e)
-            )
+            _logger.warning(f"Fail to compute 'tomo consistency' score. Reason is {e}")
             return None
     else:
         fct = _METHOD_TO_FCT.get(method, None)
@@ -187,7 +186,7 @@ def compute_score(
     if fct is not None:
         return fct(data)
     else:
-        raise ValueError("{} is not handled".format(method))
+        raise ValueError(f"{method} is not handled")
 
 
 def get_disk_mask_radius(datasets_) -> int:
@@ -214,7 +213,5 @@ def apply_roi(data, radius, url) -> numpy.array:
     try:
         return data[min_y:max_y, min_x:max_x]
     except Exception:
-        _logger.error(
-            "Fail to apply roi for {}. Take the entire dataset".format(url.path())
-        )
+        _logger.error(f"Fail to apply roi for {url.path()}. Take the entire dataset")
         return data

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

@@ -1,11 +1,13 @@
 import os
+
+import numpy
 import pytest
+
 from tomwer.core.process.reconstruction.axis.params import (
-    AxisResource,
     AxisCalculationInput,
+    AxisResource,
 )
 from tomwer.core.utils.scanutils import MockHDF5
-import numpy
 
 
 def test_axis_resource(tmp_path):

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

@@ -28,11 +28,10 @@ __license__ = "MIT"
 __date__ = "24/11/2021"
 
 
-from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.utils.scanutils import MockHDF5
 from tomwer.core.process.reconstruction.darkref.darkrefs import (
     requires_reduced_dark_and_flat,
 )
+from tomwer.core.utils.scanutils import MockEDF, MockHDF5
 
 
 def test_quick_run_necessary_edf(tmpdir):

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

@@ -1,7 +1,9 @@
 import os
+
 import numpy
 import pytest
 from silx.io.dictdump import dicttoh5
+
 from tomwer.core.process.reconstruction.darkref.darkrefscopy import DarkRefsCopy
 from tomwer.core.utils.scanutils import MockHDF5
 
@@ -91,8 +93,8 @@ def test_save_reduced_frames_to_be_copied(tmp_path):
     test save_flats_to_be_copied and save_darks_to_be_copied functions
     """
     # create raw data
-    from tomoscan.scanbase import ReducedFramesInfos
     from silx.io.url import DataUrl
+    from tomoscan.scanbase import ReducedFramesInfos
 
     raw_data = tmp_path / "raw_data"
     raw_data.mkdir()

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

@@ -1,5 +1,5 @@
-from tomwer.core.process.reconstruction.paramsbase import _ReconsParam, _get_db_fromstr
 from tomwer.core.process.reconstruction.darkref.params import DKRFRP
+from tomwer.core.process.reconstruction.paramsbase import _get_db_fromstr, _ReconsParam
 
 
 def test_paramsbase():

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

@@ -28,17 +28,21 @@ __license__ = "MIT"
 __date__ = "27/02/2021"
 
 
-import unittest
-from tomwer.core.process.reconstruction.scores.scores import compute_score_contrast_std
-from tomwer.core.process.reconstruction.scores.scores import _METHOD_TO_FCT
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
-from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-from tomwer.core.utils.scanutils import MockHDF5
 import os
-import tempfile
 import shutil
+import tempfile
+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.scores.scores import (
+    _METHOD_TO_FCT,
+    compute_score_contrast_std,
+)
+from tomwer.core.utils.scanutils import MockHDF5
+
 
 class TestScoreFunctions(unittest.TestCase):
     """Test all the score functions"""

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

@@ -28,15 +28,16 @@ __license__ = "MIT"
 __date__ = "27/02/2021"
 
 
+import os
+import shutil
+import tempfile
 import unittest
+
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
-    SADeltaBetaProcess,
     SADeltaBetaParams,
+    SADeltaBetaProcess,
 )
 from tomwer.core.utils.scanutils import MockHDF5
-import os
-import tempfile
-import shutil
 
 
 class TestSADeltaBetaProcess(unittest.TestCase):

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

@@ -1,8 +1,9 @@
+import numpy
+
 from tomwer.core.process.reconstruction.utils.cor import (
-    relative_pos_to_absolute,
     absolute_pos_to_relative,
+    relative_pos_to_absolute,
 )
-import numpy
 
 
 def test_cor_conversion():

tomwer/core/process/script/python.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "03/08/2020"
 
 
+import code
+import logging
+
+import tomwer.version
 from tomwer.core.process.task import Task
+from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.volumeutils import volume_identifier_to_volume
-import tomwer.version
-import logging
-import code
-
 
 _logger = logging.getLogger(__name__)
 
@@ -53,9 +53,7 @@ class PythonScript(
         elif isinstance(scan, (TomwerScanBase, type(None))):
             scan = scan
         else:
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
         # load volume
         volume = volume_identifier_to_volume(self.inputs.volume)
 

tomwer/core/process/task.py

@@ -34,22 +34,21 @@ __license__ = "MIT"
 __date__ = "27/07/2021"
 
 
-import h5py
-import numpy
-from datetime import datetime
-from typing import Union
-from silx.io.dictdump import dicttoh5
-from collections import namedtuple
-from silx.io.dictdump import h5todict
-from tomoscan.io import HDF5File
-import typing
 import logging
-from silx.io.utils import h5py_read_dataset
 import multiprocessing
+import typing
+from collections import namedtuple
+from datetime import datetime
+from typing import Union
+
+import h5py
+import numpy
 import silx
-from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
 from ewokscore.task import Task as _EwoksTask
-
+from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
+from silx.io.dictdump import dicttoh5, h5todict
+from silx.io.utils import h5py_read_dataset
+from tomoscan.io import HDF5File
 
 mult_manager = multiprocessing.Manager()
 

tomwer/core/process/test/test_axis.py

@@ -28,21 +28,24 @@ __license__ = "MIT"
 __date__ = "05/04/2019"
 
 
+import os
 import shutil
 import tempfile
 import unittest
-import numpy
-import os
+
 import h5py
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.utils.scanutils import MockEDF, MockHDF5
-from ..reconstruction.axis.axis import AxisProcess
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.reconstruction.axis.params import AxisRP
+import numpy
+from silx.io.utils import h5py_read_dataset
+
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.process.reconstruction.axis.params import AxisRP
 from tomwer.core.process.task import Task
-from silx.io.utils import h5py_read_dataset
+from tomwer.core.scan.edfscan import EDFTomoScan
+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
 
 
 class TestAxisIO(unittest.TestCase):

tomwer/core/process/test/test_conditions.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "19/07/2018"
 
 
-import unittest
 import shutil
 import tempfile
+import unittest
 
-from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.process.conditions.filters import (
-    RegularExpressionFilter,
     FileNameFilter,
+    RegularExpressionFilter,
 )
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.utils.scanutils import MockEDF
 
 
 class TestConditionalFilter(unittest.TestCase):
@@ -46,10 +46,10 @@ class TestConditionalFilter(unittest.TestCase):
     """
 
     def testPattern1(self):
-        filter = RegularExpressionFilter("name10")
-        self.assertTrue(filter.isFiltered("toto") is True)
-        self.assertTrue(filter.isFiltered("name10") is False)
-        self.assertTrue(filter.isFiltered("name100") is False)
+        filter_ = RegularExpressionFilter("name10")
+        self.assertTrue(filter_.isFiltered("toto") is True)
+        self.assertTrue(filter_.isFiltered("name10") is False)
+        self.assertTrue(filter_.isFiltered("name100") is False)
 
     def testInputOutput(self):
         pass

tomwer/core/process/test/test_dark_and_flat.py

@@ -32,18 +32,19 @@ import os
 import shutil
 import tempfile
 import unittest
+
 import numpy
-from tomwer.core.utils.scanutils import MockEDF, MockHDF5
-from tomwer.core.process.reconstruction.darkref.params import (
-    DKRFRP,
-    ReduceMethod as cMethod,
-)
+from tomoscan.esrf.scan.utils import get_data
+
+from tomwer.core.process.reconstruction.darkref.params import DKRFRP
+from tomwer.core.process.reconstruction.darkref.params import ReduceMethod as cMethod
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
 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.darkrefscopy import DarkRefsCopy
-from tomwer.tests.utils import UtilsTest
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.esrf.scan.utils import get_data
 
 
 class TestDarkRefIO(unittest.TestCase):

tomwer/core/process/test/test_data_listener.py

@@ -28,11 +28,13 @@ __license__ = "MIT"
 __date__ = "09/06/2020"
 
 
-import unittest
-import tempfile
-import shutil
 import os
+import shutil
+import tempfile
+import unittest
+
 import h5py
+
 from tomwer.core.process.control.datalistener.rpcserver import _BaseDataListenerThread
 
 

tomwer/core/process/test/test_data_transfer.py

@@ -30,25 +30,27 @@ __date__ = "05/04/2019"
 
 import gc
 import os
-import h5py
+import shutil
+import tempfile
 import time
+import unittest
+
+import h5py
 import numpy
 import pytest
-import shutil
-import unittest
-import tempfile
+from nxtomomill.converter import from_h5_to_nx
+from nxtomomill.io.config.hdf5config import TomoHDF5Config
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 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.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.process.control.scantransfer import ScanTransfer
-from tomwer.tests.utils import UtilsTest
+from tomwer.core.utils.scanutils import MockEDF
 from tomwer.synctools.rsyncmanager import RSyncManager
-from tomwer.core.process.control.datalistener import DataListener
-from nxtomomill.converter import from_h5_to_nx
-from nxtomomill.io.config.hdf5config import TomoHDF5Config
-from tomoscan.validator import is_valid_for_reconstruction
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from tomwer.tests.utils import UtilsTest
 
 
 class TestDataTransferIO(unittest.TestCase):

tomwer/core/process/test/test_data_watcher.py

@@ -30,10 +30,12 @@ __date__ = "05/04/2019"
 
 import os
 import time
+
 import pytest
+
+from tomwer.core.process.control.datawatcher import DataWatcher
 from tomwer.core.process.control.datawatcher.status import DET_END_XML, PARSE_INFO_FILE
 from tomwer.core.utils.scanutils import MockEDF
-from tomwer.core.process.control.datawatcher import DataWatcher
 from tomwer.core.utils.threads import LoopThread