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

tomwer/core/process/control/datalistener/rpcserver.py

@@ -27,19 +27,19 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "09/06/2020"
 
-import time
+import getpass
 import logging
+import socket
 import threading
+import time
 import typing
-from silx.utils.enum import Enum as _Enum
 from multiprocessing import Process
-from werkzeug.wrappers import Request, Response
-from werkzeug.serving import run_simple
+
 from jsonrpc import JSONRPCResponseManager, dispatcher
-import socket
 from psutil import process_iter
-import getpass
-
+from silx.utils.enum import Enum as _Enum
+from werkzeug.serving import run_simple
+from werkzeug.wrappers import Request, Response
 
 _logger = logging.getLogger(__name__)
 
@@ -177,20 +177,18 @@ class _BaseDataListenerThread:
             self.scan_added(acquisition=self._current_sequence, scan_number=scan_number)
 
     def scan_added(self, acquisition: BlissAcquisition, scan_number: int):
-        print("scan {} started".format(scan_number))
+        print(f"scan {scan_number} started")
 
     def _rpc_scan_ended(self, scan_number):
         if self._current_sequence is not None:
             self.scan_ended(acquisition=self._current_sequence, scan_number=scan_number)
 
     def scan_ended(self, acquisition: BlissAcquisition, scan_number):
-        print("scan {} ended".format(scan_number))
+        print(f"scan {scan_number} ended")
 
     def _rpc_sequence_ended(self, saving_file, sequence_scan_number, success: bool):
         if success is False:
-            _logger.warning(
-                "sequence {}@{} failed".format(sequence_scan_number, saving_file)
-            )
+            _logger.warning(f"sequence {sequence_scan_number}@{saving_file} failed")
             if self._current_sequence is not None:
                 try:
                     self.sequence_failed(self._current_sequence)
@@ -212,23 +210,18 @@ class _BaseDataListenerThread:
                 )
 
                 _logger.warning(
-                    "End of {} detected but does not fit the "
-                    "current acquisition {}".format(name, name_current)
+                    f"End of {name} detected but does not fit the current acquisition {name_current}"
                 )
 
     def sequence_ended(self, acquisition: BlissAcquisition):
         """callback when a sequence end (with success)"""
         print(
-            "sequence {}@{} ended. Succeed: {}".format(
-                acquisition.entry, acquisition.master_file, acquisition.status
-            )
+            f"sequence {acquisition.entry}@{acquisition.master_file} ended. Succeed: {acquisition.status}"
         )
 
     def sequence_failed(self, acquisition: BlissAcquisition):
         """callback when a sequence fails (probably canceled)"""
-        print(
-            "sequence {}@{} failed".format(acquisition.entry, acquisition.master_file)
-        )
+        print(f"sequence {acquisition.entry}@{acquisition.master_file} failed")
 
     @Request.application
     def application(self, request):
@@ -242,17 +235,17 @@ class _BaseDataListenerThread:
 
     def start(self) -> None:
         self._stop = False
-        _logger.info("launch rpc server on {}:{}".format(self._host, self._port))
+        _logger.info(f"launch rpc server on {self._host}:{self._port}")
         self._server = Process(
             target=run_simple, args=(self._host, self._port, self.application)
         )
         self._server.start()
-        _logger.info("launcher server with pid {}".format(self._server.pid))
+        _logger.info(f"launcher server with pid {self._server.pid}")
 
     def stop(self):
         self._stop = True
         if self._server is not None:
-            _logger.info("stop rpc server on {}:{}".format(self._host, self._port))
+            _logger.info(f"stop rpc server on {self._host}:{self._port}")
             self._server.terminate()
             self._server.join(_BaseDataListenerThread._JOIN_TIMEOUT)
             self._server = None
@@ -290,9 +283,7 @@ def send_signal_to_local_rpc_servers(signal, port, extended_find=True):
                         "tomwer",
                         "orange-canvas",
                     ):
-                        _logger.warning(
-                            "send {} signal to pid {}" "".format(signal, proc.pid)
-                        )
+                        _logger.warning(f"send {signal} signal to pid {proc.pid}")
                         proc.send_signal(signal)
                         found = True
                         return
@@ -308,8 +299,7 @@ def send_signal_to_local_rpc_servers(signal, port, extended_find=True):
                     # make sure we will kill the correct process
                     if conns.laddr.port == port:
                         _logger.warning(
-                            "process pid: {} - {} seems to be one occupying port {}"
-                            "".format(proc.pid, proc.name(), port)
+                            f"process pid: {proc.pid} - {proc.name()} seems to be one occupying port {port}"
                         )
                         return
             except (psutil.PermissionError, psutil.AccessDenied):

tomwer/core/process/control/datawatcher/datawatcher.py

@@ -30,25 +30,28 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "30/09/2019"
 
+import logging
 import os
-import time
 import threading
-from tomwer.core.scan.blissscan import BlissScan
-from tomwer.core.signal import Signal
-from tomwer.core.process.utils import LastReceivedScansDict
-from tomwer.core.process.task import BaseProcessInfo
+import time
+from typing import Optional
+
+from ewokscore.task import Task as EwoksTask
+
 from tomwer.core.process.control.datawatcher.datawatcherobserver import (
     _DataWatcherObserver,
     _OngoingObservation,
 )
-from typing import Optional
+from tomwer.core.process.task import BaseProcessInfo
+from tomwer.core.process.utils import LastReceivedScansDict
+from tomwer.core.scan.blissscan import BlissScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.settings import get_lbsram_path, get_dest_path
+from tomwer.core.settings import get_dest_path, get_lbsram_path
+from tomwer.core.signal import Signal
 from tomwer.core.utils import logconfig
+
 from .status import *  # noqa F403
-import logging
-from tomwer.core.scan.scanbase import TomwerScanBase
-from ewokscore.task import Task as EwoksTask
 
 logger = logging.getLogger(__name__)
 
@@ -284,8 +287,8 @@ class _DataWatcher(BaseProcessInfo):
 
         return True
 
-    def _messageNotDir(self, dir):
-        message = "Given path (%s) isn't a directory." % dir
+    def _messageNotDir(self, dir_):
+        message = "Given path (%s) isn't a directory." % dir_
         logger.warning(message, extra={logconfig.DOC_TITLE: self._scheme_title})
 
     def _createDataWatcher(self):

tomwer/core/process/control/datawatcher/datawatcherobserver.py

@@ -33,24 +33,27 @@ __license__ = "MIT"
 __date__ = "09/02/2017"
 
 
-from fnmatch import fnmatch
+import logging
 import os
 import threading
+import time
 from collections import OrderedDict
+from fnmatch import fnmatch
 from typing import Optional
+
+import h5py
+
 from tomwer.core.process.control.datawatcher import status as datawatcherstatus
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.threads import LoopThread
+
+from .datawatcherprocess import _DataWatchEmpty
 from .edfdwprocess import (
     _DataWatcherProcessParseInfo,
     _DataWatcherProcessUserFilePattern,
     _DataWatcherProcessXML,
 )
-from .hdf5dwprocess import _DataWatcherProcessHDF5, _BlissScanWatcherProcess
-from .datawatcherprocess import _DataWatchEmpty
-from tomwer.core.utils.threads import LoopThread
-import logging
-from tomwer.core.scan.edfscan import EDFTomoScan
-import time
-import h5py
+from .hdf5dwprocess import _BlissScanWatcherProcess, _DataWatcherProcessHDF5
 
 logger = logging.getLogger(__name__)
 

tomwer/core/process/control/datawatcher/datawatcherprocess.py

@@ -31,13 +31,15 @@ __license__ = "MIT"
 __date__ = "14/10/2016"
 
 
-from glob import glob
-import subprocess
-from tomwer.core.signal import Signal
 import logging
+import os
+import subprocess
+from glob import glob
+
 from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.signal import Signal
+
 from .status import OBSERVATION_STATUS
-import os
 
 logger = logging.getLogger(__name__)
 
@@ -168,7 +170,7 @@ class _DataWatcherProcess:
             if self.RootDir.startswith(self.srcPattern):
                 source = os.path.join(self.RootDir, self.parsing_dir)
                 target = source.replace(self.srcPattern, self.destPattern, 1)
-                info = "Start synchronization between %s and %s" % (source, target)
+                info = f"Start synchronization between {source} and {target}"
                 self.sigNewInformation.emit(info)
 
                 target_dirname = os.path.dirname(target)

tomwer/core/process/control/datawatcher/edfdwprocess.py

@@ -31,14 +31,15 @@ __license__ = "MIT"
 __date__ = "30/09/2019"
 
 
-from .datawatcherprocess import _DataWatcherProcess
 import logging
 import os
 import shutil
-from tomwer.core.scan.edfscan import EDFTomoScan
-from subprocess import getstatusoutput as myux
 from glob import glob
 
+from tomwer.core.scan.edfscan import EDFTomoScan
+
+from .datawatcherprocess import _DataWatcherProcess
+
 _logger = logging.getLogger(__name__)
 try:
     from tomwer.synctools.rsyncmanager import RSyncManager
@@ -49,17 +50,6 @@ except ImportError:
     has_rsync = True
 
 
-def get_dir_size(dir):
-    if not os.path.isdir(dir):
-        err = "%s is not a directory, can't get size" % dir
-        raise ValueError(err)
-    else:
-        aux = myux("du -ms " + dir.replace(" ", "\ "))  # noqa W605
-        if len(aux) < 2:
-            return 0
-        return float((aux[1].split("\t"))[0])
-
-
 def get_info_val(lines, key):
     r = range(len(lines))
     key = key + "="
@@ -97,7 +87,7 @@ class _DataWatcherEDFProcess(_DataWatcherProcess):
     def _removeAcquisition(self, scanID, reason):
         if os.path.exists(scanID) and os.path.isdir(scanID):
             if self._removed is None:
-                _logger.info("removing folder %s because %s" % (scanID, reason))
+                _logger.info(f"removing folder {scanID} because {reason}")
                 if has_rsync:
                     RSyncManager().removeDir(scanID)
                     # avoid multiple removal as removal is asynchronous and might

tomwer/core/process/control/datawatcher/hdf5dwprocess.py

@@ -30,10 +30,12 @@ __authors__ = ["C. Nemoz", "H. Payno"]
 __license__ = "MIT"
 __date__ = "30/09/2019"
 
-from .datawatcherprocess import _DataWatcherProcess
 import logging
+
 import h5py
 
+from .datawatcherprocess import _DataWatcherProcess
+
 _logger = logging.getLogger(__name__)
 
 

tomwer/core/process/control/datawatcher/status.py

@@ -73,3 +73,5 @@ BLISS_SCAN_END = "bliss scan - end_time dataset"
 
 
 NXtomo_END = "already converted NXtomo"
+
+EDF_SCAN_END = "Any EDF scan"

tomwer/core/process/control/nxtomomill.py

@@ -28,15 +28,16 @@ __license__ = "MIT"
 __date__ = "30/07/2020"
 
 
-from tomwer.core.utils.scanutils import format_output_location
-from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+import logging
+import os
+
 from nxtomomill import converter as nxtomomill_converter
-from nxtomomill.io.config import TomoHDF5Config as HDF5Config
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
+from nxtomomill.io.config import TomoHDF5Config as HDF5Config
 
-import os
-import logging
+from tomwer.core.process.task import TaskWithProgress
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.utils.scanutils import format_output_location
 
 _logger = logging.getLogger(__name__)
 

tomwer/core/process/control/scanlist.py

@@ -31,9 +31,10 @@ __license__ = "MIT"
 __date__ = "05/07/2017"
 
 
+import logging
+
 from tomwer.core.process.task import Task
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-import logging
 
 logger = logging.getLogger(__name__)
 

tomwer/core/process/control/scanselector.py

@@ -1,4 +1,5 @@
 from ewokscore.task import Task as EwoksTask
+
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 

tomwer/core/process/control/scantransfer.py

@@ -28,24 +28,24 @@ __license__ = "MIT"
 __date__ = "05/07/2017"
 
 
+import fnmatch
+import logging
 import os
 import shutil
-import fnmatch
 
-from tomwer.core.process.task import Task
-from tomwer.core.utils.scanutils import data_identifier_to_scan
-from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.settings import get_lbsram_path, get_dest_path
+import tomwer.version
 from tomwer.core.process.reconstruction.nabu.settings import NABU_CFG_FILE_FOLDER
 from tomwer.core.process.reconstruction.nabu.utils import update_cfg_file_after_transfer
-from tomwer.core.signal import Signal
-from tomwer.core.utils import logconfig, rebaseParFile
-import logging
-from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.settings import get_dest_path, get_lbsram_path
+from tomwer.core.signal import Signal
+from tomwer.core.utils import logconfig, rebaseParFile
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.io.utils import get_linked_files_with_entry
-import tomwer.version
 
 logger = logging.getLogger(__name__)
 
@@ -521,7 +521,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
             configuration=None,
         )
         logger.processSucceed(
-            "transfer succeed of {} to {}".format(str(input_scan), str(output_scan)),
+            f"transfer succeed of {input_scan} to {output_scan}",
             extra={
                 logconfig.DOC_TITLE: self._scheme_title,
                 logconfig.FROM: str(input_scan),
@@ -646,7 +646,7 @@ class ScanTransfer(Task, input_names=("data",), output_names=("data",)):
             print("### copying files ", scanID, " to ", outputdir)
             print("### ...")
 
-        info = "start moving folder from %s to %s" % (scanID, outputdir)
+        info = f"start moving folder from {scanID} to {outputdir}"
         logger.processStarted(info, extra={logconfig.DOC_TITLE: self._scheme_title})
 
     def _signalCopyFailed(self):

tomwer/core/process/control/scanvalidator.py

@@ -27,16 +27,17 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "18/06/2017"
 
-from tomwer.core.signal import Signal
-from tomwer.core import settings
-from tomwer.core import utils
+import logging
+
+from ewokscore.task import Task as EwoksTask
+
+from tomwer.core import settings, utils
 from tomwer.core.process.task import BaseProcessInfo
+from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.signal import Signal
 from tomwer.core.utils import logconfig
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-import logging
-from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
-from ewokscore.task import Task as EwoksTask
 
 logger = logging.getLogger(__name__)
 

tomwer/core/process/control/test/test_volume_link.py

@@ -28,13 +28,14 @@ __license__ = "MIT"
 __date__ = "16/06/2021"
 
 
+import os
+import shutil
+import tempfile
 import unittest
+
 from tomwer.core.process.control.volumesymlink import VolumeSymbolicLinkProcess
-from tomwer.core.utils.scanutils import MockEDF
 from tomwer.core.scan.edfscan import EDFTomoScan
-import tempfile
-import shutil
-import os
+from tomwer.core.utils.scanutils import MockEDF
 
 
 class TestVolumeSymbolicLink(unittest.TestCase):

tomwer/core/process/control/timer.py

@@ -28,12 +28,13 @@ __license__ = "MIT"
 __date__ = "12/12/2018"
 
 
+import logging
+import time
+
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-import time
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -74,8 +75,7 @@ class Timer(Task, input_names=("data",), output_names=("data",)):
             scan = scan
         if not isinstance(scan, TomwerScanBase):
             raise TypeError(
-                "scan is expected to be a dict or an instance "
-                "of TomwerScanBase. Not {}".format(type(scan))
+                f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
         time.sleep(self.waiting_time)
         if self._return_dict:

tomwer/core/process/control/volumeselector.py

@@ -1,4 +1,5 @@
 from ewokscore.task import Task as EwoksTask
+
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 

tomwer/core/process/control/volumesymlink.py

@@ -29,16 +29,18 @@ __date__ = "16/11/2020"
 
 
 import logging
-from tomwer.core.scan.scanbase import TomwerScanBase
+import os
+
+from silx.utils.enum import Enum as _Enum
 from tomoscan.factory import Factory
 from tomoscan.volumebase import VolumeBase
+
+import tomwer.version
 from tomwer.core.process.task import Task
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-from silx.utils.enum import Enum as _Enum
 from tomwer.utils import docstring
-import tomwer.version
-import os
 
 _logger = logging.getLogger(__name__)
 
@@ -128,8 +130,7 @@ class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data
             return
         if not isinstance(scan, TomwerScanBase):
             raise TypeError(
-                "scan is expected to be a dict or an instance "
-                "of TomwerScanBase. Not {}".format(type(scan))
+                f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
 
         if self._output_type is OutputType.STATIC:
@@ -150,9 +151,7 @@ class VolumeSymbolicLinkProcess(Task, input_names=("data",), output_names=("data
                 os.path.join(output_folder, self._output_type.value)
             )
         else:
-            raise ValueError(
-                "output type {} is not managed".format(self._output_type.value)
-            )
+            raise ValueError(f"output type {self._output_type.value} is not managed")
         create_volume_symbolic_link(scan=scan, output_folder=output_folder)
         self.outputs.data = scan
 

tomwer/core/process/edit/darkflatpatch.py

@@ -28,14 +28,15 @@ __license__ = "MIT"
 __date__ = "04/11/2020"
 
 
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import data_identifier_to_scan
+import nxtomomill.version
 from nxtomomill.utils import add_dark_flat_nx_file
+from silx.io.url import DataUrl
+
 from tomwer.core.process.task import Task
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
-from silx.io.url import DataUrl
-import nxtomomill.version
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 def apply_dark_flat_patch(scan: HDF5TomoScan, config: dict) -> TomwerScanBase:
@@ -47,8 +48,7 @@ def apply_dark_flat_patch(scan: HDF5TomoScan, config: dict) -> TomwerScanBase:
     """
     if not isinstance(scan, HDF5TomoScan):
         raise ValueError(
-            "Dark and flat patch only manage HDF5TomoScan and "
-            "not {}".format(type(scan))
+            f"Dark and flat patch only manage HDF5TomoScan and not {type(scan)}"
         )
     if config is None:
         return scan
@@ -79,13 +79,10 @@ class DarkFlatPatch(Task, input_names=("data",), output_names=("data",)):
             return
         if not isinstance(scan, TomwerScanBase):
             raise TypeError(
-                "scan is expected to be a dict or an instance "
-                "of TomwerScanBase. Not {}".format(type(scan))
+                f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
         if not isinstance(scan, HDF5TomoScan):
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
 
         config = self.get_configuration()
         apply_dark_flat_patch(scan=scan, config=config)

tomwer/core/process/edit/imagekeyeditor.py

@@ -28,16 +28,18 @@ __license__ = "MIT"
 __date__ = "26/10/2020"
 
 
+import logging
+
+import nxtomomill.version
+from nxtomomill.utils import change_image_key_control as _change_image_key_control
+from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomoscan.esrf.scan.hdf5scan import ImageKey as _ImageKey
+
+from tomwer.core.process.task import Task
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
-from nxtomomill.utils import change_image_key_control as _change_image_key_control
-from tomwer.core.process.task import Task
-from tomoscan.esrf.scan.hdf5scan import ImageKey
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import data_identifier_to_scan
-import nxtomomill.version
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -63,8 +65,7 @@ def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase
         return
     elif not isinstance(scan, HDF5TomoScan):
         raise ValueError(
-            "Image key control only handle HDF5TomoScan and "
-            "not {}".format(type(scan))
+            f"Image key control only handle HDF5TomoScan and not {type(scan)}"
         )
 
     if "modifications" not in config:
@@ -83,7 +84,7 @@ def change_image_key_control(scan: HDF5TomoScan, config: dict) -> TomwerScanBase
             filter(lambda item: item[1] is image_key_type, modifications.items())
         )
         frame_indexes = tuple(frame_indexes_dict.keys())
-        _logger.warning("will modify {} to {}".format(frame_indexes, image_key_type))
+        _logger.warning(f"will modify {frame_indexes} to {image_key_type}")
         _change_image_key_control(
             file_path=scan.master_file,
             entry=scan.entry,
@@ -118,13 +119,10 @@ class ImageKeyEditor(Task, input_names=("data",), output_names=("data",)):
             return
         if not isinstance(scan, TomwerScanBase):
             raise TypeError(
-                "scan is expected to be a dict or an instance "
-                "of TomwerScanBase. Not {}".format(type(scan))
+                f"scan is expected to be a dict or an instance of TomwerScanBase. Not {type(scan)}"
             )
         if not isinstance(scan, HDF5TomoScan):
-            raise ValueError(
-                "input type of {}: {} is not managed" "".format(scan, type(scan))
-            )
+            raise ValueError(f"input type of {scan}: {(type(scan))} is not managed")
 
         change_image_key_control(scan=scan, config=self.get_configuration())
         config = self.get_configuration()